@woosh/meep-engine 3.57.0 → 3.59.0

package/src/generation/foliage/asset/tree_shoot_prototypes.d.ts

@@ -0,0 +1,155 @@
+/**
+ * @typedef {Object} TreeShootPrototype
+ * @property {number} generator its carrier's generator, a shoot rule's `source`
+ * @property {number} carrier the framework branch it grew on
+ * @property {number} length m, its carrier's in the framework: what a carrier it is drawn on is scaled against
+ * @property {number} first its carrier's branch in `TreeShootPrototypes.sheet`; its shoots follow it
+ * @property {number} branch_count its branches in the sheet, from `first`
+ * @property {Array<{parent: number, t: number, leaf_area: number, reach: number}>} carried each shoot system on it that
+ *           no LOD draws as wood, hanging from drawn wood: the sheet branch and `t_norm` it hangs from, its one-sided leaf
+ *           area (m^2) and how far it reaches from there (m), as the wind's mechanics weigh them
+ */
+/**
+ * @typedef {Object} TreeShootPrototypes
+ * @property {import("../config/TreeSpeciesConfig.js").TreeSpeciesConfig} species the species as its prototypes grew,
+ *           at {@link PROTOTYPE_SEED}
+ * @property {TreeSkeleton} framework the species' framework, grown by its generator graph alone
+ * @property {TreeShootPrototype[]} prototypes
+ * @property {Map<number, {lengths: Float64Array, low: number, high: number}>} carriers per carrier generator, its
+ *           carriers' lengths (ascending), and the scale a prototype may be drawn at, its leaves' own spread
+ *           (`foliage_scale_spread`)
+ * @property {TreeSkeleton} sheet every prototype where it grew on the framework, under the framework's crown frame
+ * @property {import("../mesh/foliage_collect_attachments.js").FoliageAttachmentSet} attachments the sheet's leaves
+ * @property {import("../../../shade/renderer/geometry/Geometry.js").Geometry|null} leaves every leaf's card
+ * @property {number} side_area m^2, every prototype's grown side area together
+ * @property {number[]} errors m, each error the sheet was cut at: {@link TREE_LOD_ERROR_STEP} apart from
+ *           {@link TREE_LOD_ERROR_FINEST} to the first that draws no wood, every prototype one cut
+ * @property {ReturnType<typeof tree_cluster_atlas>|null} atlas their cuts at every error, drawn with a few tiles, as
+ *           large as the texture ceiling affords over {@link side_area}
+ * @property {Uint8Array} drawn per sheet branch, whether any LOD draws it as wood: the finest error does, and so does
+ *           its parent; a carrier always is
+ * @property {Int32Array} prototype_of per sheet branch, its prototype
+ * @property {Int32Array[]} owners per error, each card's prototype
+ */
+/**
+ * A species' shoot prototypes (TWO_FRONT_ENDS_BRIEF_2026_10_28.md, G1): the shoot systems its shoot rules grow, grown
+ * once, by the botanical front end, on carriers of its own framework, and cut and baked into one atlas. A tree grown by
+ * its generator graph draws them on its carriers (G3).
+ *
+ * - **Where.** Each grows on a carrier of the framework the species' graph grows, in place: as old as that carrier is
+ *   in the tree, kept out of the framework's wood, in the light of its own leaves alone (`tree_skeleton_grow_shoots_on`).
+ *   It stays there: its leaves are collected, cut and baked where they grew, under the framework's crown frame, as a
+ *   tree's own are.
+ * - **Which.** For each generator the rules grow on, the carrier of median length first. Drawn on a carrier of another
+ *   length, a prototype is scaled by their ratio, and so are its leaves; within the spread of sizes the species' leaves
+ *   already grow to, a scaled leaf is one it grows (`foliage_scale_spread`). Prototypes are added, shortest first, until
+ *   their scaled lengths reach without a gap from the shortest carrier to the longest, each the longest carrier that
+ *   still reaches back to where the last one stopped.
+ * - **Cut.** At every error from the finest to where no wood is drawn, through the same cuts, representatives and bake
+ *   a tree's own LODs take (`tree_cluster_atlas`).
+ *
+ * @param {import("../config/TreeSpeciesConfig.js").TreeSpeciesConfig} species
+ * @param {import("../../../shade/renderer/material/StandardShadeMaterial.js").StandardShadeMaterial} leaf_material
+ *        the species' leaf material (`TreeSpeciesCache.leaves`)
+ * @param {import("../material/FoliageAtlasCutout.js").FoliageAtlasCutout|null} cutout its atlas's shape, `null` for a
+ *        caller's own material, whose cards cover whole tiles
+ * @returns {TreeShootPrototypes}
+ */
+export function tree_shoot_prototypes(species: import("../config/TreeSpeciesConfig.js").TreeSpeciesConfig, leaf_material: import("../../../shade/renderer/material/StandardShadeMaterial.js").StandardShadeMaterial, cutout: import("../material/FoliageAtlasCutout.js").FoliageAtlasCutout | null): TreeShootPrototypes;
+export type TreeShootPrototype = {
+    /**
+     * its carrier's generator, a shoot rule's `source`
+     */
+    generator: number;
+    /**
+     * the framework branch it grew on
+     */
+    carrier: number;
+    /**
+     * m, its carrier's in the framework: what a carrier it is drawn on is scaled against
+     */
+    length: number;
+    /**
+     * its carrier's branch in `TreeShootPrototypes.sheet`; its shoots follow it
+     */
+    first: number;
+    /**
+     * its branches in the sheet, from `first`
+     */
+    branch_count: number;
+    /**
+     * each shoot system on it that
+     * no LOD draws as wood, hanging from drawn wood: the sheet branch and `t_norm` it hangs from, its one-sided leaf
+     * area (m^2) and how far it reaches from there (m), as the wind's mechanics weigh them
+     */
+    carried: Array<{
+        parent: number;
+        t: number;
+        leaf_area: number;
+        reach: number;
+    }>;
+};
+export type TreeShootPrototypes = {
+    /**
+     * the species as its prototypes grew,
+     * at {@link PROTOTYPE_SEED }
+     */
+    species: import("../config/TreeSpeciesConfig.js").TreeSpeciesConfig;
+    /**
+     * the species' framework, grown by its generator graph alone
+     */
+    framework: TreeSkeleton;
+    prototypes: TreeShootPrototype[];
+    /**
+     * per carrier generator, its
+     * carriers' lengths (ascending), and the scale a prototype may be drawn at, its leaves' own spread
+     * (`foliage_scale_spread`)
+     */
+    carriers: Map<number, {
+        lengths: Float64Array;
+        low: number;
+        high: number;
+    }>;
+    /**
+     * every prototype where it grew on the framework, under the framework's crown frame
+     */
+    sheet: TreeSkeleton;
+    /**
+     * the sheet's leaves
+     */
+    attachments: import("../mesh/foliage_collect_attachments.js").FoliageAttachmentSet;
+    /**
+     * every leaf's card
+     */
+    leaves: import("../../../shade/renderer/geometry/Geometry.js").Geometry | null;
+    /**
+     * m^2, every prototype's grown side area together
+     */
+    side_area: number;
+    /**
+     * m, each error the sheet was cut at: {@link TREE_LOD_ERROR_STEP } apart from
+     * {@link TREE_LOD_ERROR_FINEST } to the first that draws no wood, every prototype one cut
+     */
+    errors: number[];
+    /**
+     * their cuts at every error, drawn with a few tiles, as
+     * large as the texture ceiling affords over {@link side_area }
+     */
+    atlas: ReturnType<typeof tree_cluster_atlas> | null;
+    /**
+     * per sheet branch, whether any LOD draws it as wood: the finest error does, and so does
+     * its parent; a carrier always is
+     */
+    drawn: Uint8Array;
+    /**
+     * per sheet branch, its prototype
+     */
+    prototype_of: Int32Array;
+    /**
+     * per error, each card's prototype
+     */
+    owners: Int32Array[];
+};
+import { TreeSkeleton } from "../skeleton/TreeSkeleton.js";
+import { tree_cluster_atlas } from "../material/tree_cluster_atlas.js";
+//# sourceMappingURL=tree_shoot_prototypes.d.ts.map

package/src/generation/foliage/asset/tree_shoot_prototypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree_shoot_prototypes.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/asset/tree_shoot_prototypes.js"],"names":[],"mappings":"AAmBA;;;;;;;;;;GAUG;AAEH;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,+CAPW,OAAO,gCAAgC,EAAE,iBAAiB,iBAC1D,OAAO,2DAA2D,EAAE,qBAAqB,UAEzF,OAAO,mCAAmC,EAAE,kBAAkB,GAAC,IAAI,GAEjE,mBAAmB,CAiJ/B;;;;;eAxMa,MAAM;;;;aACN,MAAM;;;;YACN,MAAM;;;;WACN,MAAM;;;;kBACN,MAAM;;;;;;aACN,MAAM;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC,CAAC;;;;;;;aAOpE,OAAO,gCAAgC,EAAE,iBAAiB;;;;eAE1D,YAAY;gBACZ,kBAAkB,EAAE;;;;;;cACpB,IAAI,MAAM,EAAE;QAAC,OAAO,EAAE,YAAY,CAAC;QAAC,GAAG,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,CAAC;;;;WAG/D,YAAY;;;;iBACZ,OAAO,wCAAwC,EAAE,oBAAoB;;;;YACrE,OAAO,8CAA8C,EAAE,QAAQ,GAAC,IAAI;;;;eACpE,MAAM;;;;;YACN,MAAM,EAAE;;;;;WAER,WAAW,yBAAyB,CAAC,GAAC,IAAI;;;;;WAE1C,UAAU;;;;kBAEV,UAAU;;;;YACV,UAAU,EAAE;;6BA5CG,6BAA6B;mCALvB,mCAAmC"}

package/src/generation/foliage/asset/tree_shoot_prototypes.js

@@ -0,0 +1,251 @@
+import { TREE_RENDER_COST_CEILING, tree_grown_side_area } from "../analysis/tree_render_cost.js";
+import { TREE_LOD_ERROR_FINEST, TREE_LOD_ERROR_STEP } from "../config/TreeLODConfig.js";
+import { tree_cluster_atlas } from "../material/tree_cluster_atlas.js";
+import { foliage_collect_attachments } from "../mesh/foliage_collect_attachments.js";
+import { foliage_scale_spread } from "../mesh/foliage_scale_spread.js";
+import { tree_mesh_compute_branch_rings } from "../mesh/tree_mesh_build_bark.js";
+import { tree_mesh_build_foliage } from "../mesh/tree_mesh_build_foliage.js";
+import { TreeSkeleton } from "../skeleton/TreeSkeleton.js";
+import { tree_skeleton_compute_segment_mechanics } from "../skeleton/tree_skeleton_compute_joint_mechanics.js";
+import { tree_skeleton_copy_branches } from "../skeleton/tree_skeleton_copy_branches.js";
+import { tree_skeleton_grow_framework } from "../skeleton/tree_skeleton_grow_framework.js";
+import { tree_skeleton_grow_shoots_on } from "../skeleton/tree_skeleton_grow_shoots.js";
+
+/**
+ * The seed a species' prototypes grow from: they are the species', whatever a tree's seed.
+ * @type {number}
+ */
+const PROTOTYPE_SEED = 0;
+
+/**
+ * @typedef {Object} TreeShootPrototype
+ * @property {number} generator its carrier's generator, a shoot rule's `source`
+ * @property {number} carrier the framework branch it grew on
+ * @property {number} length m, its carrier's in the framework: what a carrier it is drawn on is scaled against
+ * @property {number} first its carrier's branch in `TreeShootPrototypes.sheet`; its shoots follow it
+ * @property {number} branch_count its branches in the sheet, from `first`
+ * @property {Array<{parent: number, t: number, leaf_area: number, reach: number}>} carried each shoot system on it that
+ *           no LOD draws as wood, hanging from drawn wood: the sheet branch and `t_norm` it hangs from, its one-sided leaf
+ *           area (m^2) and how far it reaches from there (m), as the wind's mechanics weigh them
+ */
+
+/**
+ * @typedef {Object} TreeShootPrototypes
+ * @property {import("../config/TreeSpeciesConfig.js").TreeSpeciesConfig} species the species as its prototypes grew,
+ *           at {@link PROTOTYPE_SEED}
+ * @property {TreeSkeleton} framework the species' framework, grown by its generator graph alone
+ * @property {TreeShootPrototype[]} prototypes
+ * @property {Map<number, {lengths: Float64Array, low: number, high: number}>} carriers per carrier generator, its
+ *           carriers' lengths (ascending), and the scale a prototype may be drawn at, its leaves' own spread
+ *           (`foliage_scale_spread`)
+ * @property {TreeSkeleton} sheet every prototype where it grew on the framework, under the framework's crown frame
+ * @property {import("../mesh/foliage_collect_attachments.js").FoliageAttachmentSet} attachments the sheet's leaves
+ * @property {import("../../../shade/renderer/geometry/Geometry.js").Geometry|null} leaves every leaf's card
+ * @property {number} side_area m^2, every prototype's grown side area together
+ * @property {number[]} errors m, each error the sheet was cut at: {@link TREE_LOD_ERROR_STEP} apart from
+ *           {@link TREE_LOD_ERROR_FINEST} to the first that draws no wood, every prototype one cut
+ * @property {ReturnType<typeof tree_cluster_atlas>|null} atlas their cuts at every error, drawn with a few tiles, as
+ *           large as the texture ceiling affords over {@link side_area}
+ * @property {Uint8Array} drawn per sheet branch, whether any LOD draws it as wood: the finest error does, and so does
+ *           its parent; a carrier always is
+ * @property {Int32Array} prototype_of per sheet branch, its prototype
+ * @property {Int32Array[]} owners per error, each card's prototype
+ */
+
+/**
+ * A species' shoot prototypes (TWO_FRONT_ENDS_BRIEF_2026_10_28.md, G1): the shoot systems its shoot rules grow, grown
+ * once, by the botanical front end, on carriers of its own framework, and cut and baked into one atlas. A tree grown by
+ * its generator graph draws them on its carriers (G3).
+ *
+ * - **Where.** Each grows on a carrier of the framework the species' graph grows, in place: as old as that carrier is
+ *   in the tree, kept out of the framework's wood, in the light of its own leaves alone (`tree_skeleton_grow_shoots_on`).
+ *   It stays there: its leaves are collected, cut and baked where they grew, under the framework's crown frame, as a
+ *   tree's own are.
+ * - **Which.** For each generator the rules grow on, the carrier of median length first. Drawn on a carrier of another
+ *   length, a prototype is scaled by their ratio, and so are its leaves; within the spread of sizes the species' leaves
+ *   already grow to, a scaled leaf is one it grows (`foliage_scale_spread`). Prototypes are added, shortest first, until
+ *   their scaled lengths reach without a gap from the shortest carrier to the longest, each the longest carrier that
+ *   still reaches back to where the last one stopped.
+ * - **Cut.** At every error from the finest to where no wood is drawn, through the same cuts, representatives and bake
+ *   a tree's own LODs take (`tree_cluster_atlas`).
+ *
+ * @param {import("../config/TreeSpeciesConfig.js").TreeSpeciesConfig} species
+ * @param {import("../../../shade/renderer/material/StandardShadeMaterial.js").StandardShadeMaterial} leaf_material
+ *        the species' leaf material (`TreeSpeciesCache.leaves`)
+ * @param {import("../material/FoliageAtlasCutout.js").FoliageAtlasCutout|null} cutout its atlas's shape, `null` for a
+ *        caller's own material, whose cards cover whole tiles
+ * @returns {TreeShootPrototypes}
+ */
+export function tree_shoot_prototypes(species, leaf_material, cutout) {
+    const config = species.clone();
+    config.seed = PROTOTYPE_SEED;
+    const framework = tree_skeleton_grow_framework(config);
+
+    // each carrier's shoot systems, grown in place on a framework of its own
+    const grown = new Map();
+    const grow = (carrier) => {
+        let skeleton = grown.get(carrier);
+        if (skeleton === undefined) {
+            skeleton = framework.clone();
+            const on = new Uint8Array(framework.branch_count);
+            on[carrier] = 1;
+            tree_skeleton_grow_shoots_on(skeleton, config, on);
+            grown.set(carrier, skeleton);
+        }
+        return skeleton;
+    };
+
+    const generators = [...new Set(config.shoot_rules.map(rule => rule.source))].sort((a, b) => a - b);
+    /** @type {TreeShootPrototype[]} */
+    const prototypes = [];
+    const carriers = new Map();
+    for (const generator of generators) {
+        const of_generator = [];
+        for (let b = 0; b < framework.branch_count; b++) {
+            if (framework.branch_generator[b] === generator && !framework.branch_dead[b] && framework.branch_length[b] > 0) {
+                of_generator.push(b);
+            }
+        }
+        if (of_generator.length === 0) continue;
+        of_generator.sort((a, b) => framework.branch_length[a] - framework.branch_length[b]);
+        const lengths = Float64Array.from(of_generator, b => framework.branch_length[b]);
+        const n = lengths.length;
+
+        // the median carrier's leaves say how far a prototype may be scaled; a system without leaves, any
+        const median = of_generator[n >> 1];
+        grow(median);
+        const own = foliage_collect_attachments(in_place(framework, grown, [median]), config, cutout);
+        const { low, high } = own.count > 0 ? foliage_scale_spread(own.scales, own.count) : { low: 0, high: Infinity };
+        carriers.set(generator, { lengths, low, high });
+
+        // `need`: the shortest length not yet reached, or, once `reached`, the longest that is
+        let need = lengths[0];
+        let reached = false;
+        for (; ;) {
+            // the longest carrier that scales down to it
+            let k = 0;
+            while (k + 1 < n && lengths[k + 1] * low <= need) k++;
+            if (reached && lengths[k] * high <= need) {
+                // none reaches further: no carrier's length lies past it within reach, so on to the next that does
+                let j = 0;
+                while (j < n && lengths[j] <= need) j++;
+                if (j === n) break;
+                need = lengths[j];
+                reached = false;
+                continue;
+            }
+            grow(of_generator[k]);
+            prototypes.push({ generator, carrier: of_generator[k], length: lengths[k], first: 0, branch_count: 0, carried: [] });
+            need = lengths[k] * high;
+            reached = true;
+            if (need >= lengths[n - 1]) break;
+        }
+    }
+
+    // every prototype where it grew, one skeleton
+    const sheet = in_place(framework, grown, prototypes.map(p => p.carrier), prototypes);
+    const attachments = foliage_collect_attachments(sheet, config, cutout);
+    const leaves = attachments.count > 0 ? tree_mesh_build_foliage(sheet, attachments, config, cutout) : null;
+    let side_area = 0;
+    for (const prototype of prototypes) {
+        const one = in_place(framework, grown, [prototype.carrier]);
+        const own = foliage_collect_attachments(one, config, cutout);
+        side_area += tree_grown_side_area(one, own.count > 0 ? tree_mesh_build_foliage(one, own, config, cutout) : null);
+    }
+
+    // the error ladder, to where no wood is drawn
+    const errors = [];
+    const lods = [];
+    const planned = new Map();
+    for (let error = TREE_LOD_ERROR_FINEST; ; error *= TREE_LOD_ERROR_STEP) {
+        const lod = config.lods[0].clone();
+        lod.error = error;
+        const rings = tree_mesh_compute_branch_rings(sheet, config, lod);
+        planned.set(error, rings);
+        errors.push(error);
+        lods.push(lod);
+        if (rings.size === 0) break;
+    }
+    const atlas = leaves !== null
+        ? tree_cluster_atlas(sheet, config, attachments, leaves, lods, leaf_material, TREE_RENDER_COST_CEILING.texture_density * side_area, planned)
+        : null;
+
+    // what any LOD can draw as wood: what the finest error draws, from the carrier out
+    const prototype_of = new Int32Array(sheet.branch_count).fill(-1);
+    const drawn = new Uint8Array(sheet.branch_count);
+    const finest = planned.get(TREE_LOD_ERROR_FINEST);
+    for (let i = 0; i < prototypes.length; i++) {
+        const q = prototypes[i];
+        prototype_of.fill(i, q.first, q.first + q.branch_count);
+        drawn[q.first] = 1;
+        for (let b = q.first + 1; b < q.first + q.branch_count; b++) {
+            drawn[b] = finest.has(b) && drawn[sheet.branch_parent[b]] ? 1 : 0;
+        }
+    }
+    const owners = atlas === null ? [] : atlas.lods.map(({ clusters, cards }) => Int32Array.from(cards, card => {
+        const cluster = clusters[card.cluster];
+        return prototype_of[cluster.branch >= 0 ? cluster.branch : cluster.root];
+    }));
+
+    // what each carries without drawing it as wood: the shoot systems hanging from its drawn wood, weighed as the
+    // wind's mechanics weigh the wood they would hang from
+    const mechanics = tree_skeleton_compute_segment_mechanics(sheet, config);
+    const top = new Int32Array(sheet.branch_count).fill(-1);
+    const area = new Float64Array(sheet.branch_count);
+    for (const q of prototypes) {
+        for (let b = q.first + 1; b < q.first + q.branch_count; b++) {
+            if (drawn[b]) continue;
+            const p = sheet.branch_parent[b];
+            top[b] = drawn[p] ? b : top[p];
+        }
+    }
+    for (let e = 0; e < sheet.segment_count; e++) {
+        const r = top[sheet.node_branch_id(sheet.segment_v1(e))];
+        if (r >= 0) area[r] += mechanics.leaf_area[e];
+    }
+    const nodes = [], edges = [];
+    const at = new Float64Array(3);
+    for (const q of prototypes) {
+        q.carried = [];
+        for (let r = q.first + 1; r < q.first + q.branch_count; r++) {
+            if (top[r] !== r) continue;
+            sheet.collect_branch_chain(r, nodes, edges);
+            if (edges.length === 0) continue;
+            // from where it hangs to the middle of its first segment, and on as far as that segment carries
+            sheet.node_read_position(at, 0, nodes[0]);
+            const e0 = edges[0];
+            const reach = mechanics.reach[e0] + Math.hypot(mechanics.mid[e0 * 3] - at[0], mechanics.mid[e0 * 3 + 1] - at[1], mechanics.mid[e0 * 3 + 2] - at[2]);
+            q.carried.push({ parent: sheet.branch_parent[r], t: sheet.branch_parent_attach_t[r], leaf_area: area[r], reach });
+        }
+    }
+    return { species: config, framework, prototypes, carriers, sheet, attachments, leaves, side_area, errors, atlas, drawn, prototype_of, owners };
+}
+
+/**
+ * The shoot systems of `carriers`, each with its carrier, where they grew on the framework (`grown`), in one skeleton
+ * under the framework's crown frame.
+ *
+ * @param {TreeSkeleton} framework
+ * @param {Map<number, TreeSkeleton>} grown each carrier's framework with its shoot systems grown
+ * @param {number[]} carriers
+ * @param {TreeShootPrototype[]} [records] where each carrier's branches land in the skeleton, recorded on its prototype
+ * @returns {TreeSkeleton}
+ */
+function in_place(framework, grown, carriers, records) {
+    const out = new TreeSkeleton();
+    for (let i = 0; i < carriers.length; i++) {
+        const carrier = carriers[i];
+        const skeleton = grown.get(carrier);
+        // the carrier, and every shoot: after the framework, mothers before their laterals
+        const branches = [carrier];
+        for (let b = framework.branch_count; b < skeleton.branch_count; b++) branches.push(b);
+        if (records !== undefined) {
+            records[i].first = out.branch_count;
+            records[i].branch_count = branches.length;
+        }
+        tree_skeleton_copy_branches(skeleton, branches, out);
+    }
+    out.crown_center.set(framework.crown_center);
+    out.crown_radii.set(framework.crown_radii);
+    return out;
+}

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

@@ -14,16 +14,6 @@ export class BranchGeneratorConfig {
      * @type {number}
      */
     segments: number;
-    /**
-     * Maximum radial vertices around the branch base (>= 3).
-     * @type {number}
-     */
-    radial_segments_max: number;
-    /**
-     * Minimum radial vertices at the branch tip (>= 3).
-     * @type {number}
-     */
-    radial_segments_min: number;
     /**
      * Nominal length in meters (scaled per child by the spawning rule's `length_profile`).
      * @type {number}

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

@@ -1 +1 @@
-{"version":3,"file":"BranchGeneratorConfig.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/config/BranchGeneratorConfig.js"],"names":[],"mappings":"AAMA;;;;GAIG;AACH;IAmRI;;;OAGG;IACH,sBAHW,QAAQ,qBAAqB,CAAC,GAC5B,qBAAqB,CAMjC;IA1RD;;;OAGG;IACH,UAFU,MAAM,CAEH;IAEb;;;OAGG;IACH,qBAFU,MAAM,CAES;IAEzB;;;OAGG;IACH,qBAFU,MAAM,CAEQ;IAExB;;;OAGG;IACH,QAFU,MAAM,CAEH;IAEb;;;OAGG;IACH,iBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,cAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,OAFU,MAAM,CAEH;IAEb;;;OAGG;IACH,gBAFU,cAAc,CAE8B;IAEtD;;;OAGG;IACH,WAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,YAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,cAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,cAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,cAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,gBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,iBAFU,MAAM,CAEO;IAEvB;;;OAGG;IACH,mBAFU,MAAM,CAEQ;IAExB;;;OAGG;IACH,aAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,aAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,iBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,oBAFU,MAAM,CAEU;IAE1B;;;OAGG;IACH,aAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,iBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,iBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,iBAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,mBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,qBAFU,MAAM,CAEW;IAE3B;;;OAGG;IACH,qBAFU,MAAM,CAEW;IAE3B;;;OAGG;IACH,qBAFU,MAAM,CAEW;IAE3B;;;OAGG;IACH,qBAFU,MAAM,CAEW;IAE3B;;;OAGG;IACH,YAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,qBAFU,MAAM,CAEW;IAE3B;;;OAGG;IACH,kBAFU,MAAM,CAEQ;IAExB;;;OAGG;IACH,gBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,YAFU,MAAM,CAEE;IAElB;;;;;;;;;;;;;;OAcG;IACH,eAFU,MAAM,CAEI;IAEpB;;;;;OAKG;IACH,cAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,mBAFU,MAAM,CAES;IAEzB;;;OAGG;IACH,mBAFU,MAAM,CAES;IAEzB;;;;OAIG;IACH,qBAFU,MAAM,CAEW;IAE3B;;;;OAIG;IACH,WAFU,OAAO,CAEC;IAElB;;;;;;OAMG;IACH,MAFU,OAAO,CAEJ;IAEb;;;;;;;OAOG;IACH,cAFU,MAAM,CAEG;IAYnB;;;OAGG;IACH,2BAHW,QAAQ,qBAAqB,CAAC,GAC5B,IAAI,CAoDhB;IAED;;;OAGG;IACH,YAHW,qBAAqB,GACnB,IAAI,CA+ChB;IAED;;OAEG;IACH,SAFa,qBAAqB,CAMjC;IAED;;;OAGG;IACH,cAHW,qBAAqB,GACnB,OAAO,CA+CnB;IAED;;OAEG;IACH,QAFa,MAAM,CAqBlB;IAGL;;;OAGG;IACH,kCAFU,OAAO,CAEsC;CANtD;+BAle8B,mDAAmD"}
+{"version":3,"file":"BranchGeneratorConfig.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/config/BranchGeneratorConfig.js"],"names":[],"mappings":"AAMA;;;;GAIG;AACH;IAuQI;;;OAGG;IACH,sBAHW,QAAQ,qBAAqB,CAAC,GAC5B,qBAAqB,CAMjC;IA9QD;;;OAGG;IACH,UAFU,MAAM,CAEH;IAEb;;;OAGG;IACH,QAFU,MAAM,CAEH;IAEb;;;OAGG;IACH,iBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,cAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,OAFU,MAAM,CAEH;IAEb;;;OAGG;IACH,gBAFU,cAAc,CAE8B;IAEtD;;;OAGG;IACH,WAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,YAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,cAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,cAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,cAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,gBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,iBAFU,MAAM,CAEO;IAEvB;;;OAGG;IACH,mBAFU,MAAM,CAEQ;IAExB;;;OAGG;IACH,aAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,aAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,iBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,oBAFU,MAAM,CAEU;IAE1B;;;OAGG;IACH,aAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,iBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,iBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,iBAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,mBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,qBAFU,MAAM,CAEW;IAE3B;;;OAGG;IACH,qBAFU,MAAM,CAEW;IAE3B;;;OAGG;IACH,qBAFU,MAAM,CAEW;IAE3B;;;OAGG;IACH,qBAFU,MAAM,CAEW;IAE3B;;;OAGG;IACH,YAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,qBAFU,MAAM,CAEW;IAE3B;;;OAGG;IACH,kBAFU,MAAM,CAEQ;IAExB;;;OAGG;IACH,gBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,YAFU,MAAM,CAEE;IAElB;;;;;;;;;;;;;;OAcG;IACH,eAFU,MAAM,CAEI;IAEpB;;;;;OAKG;IACH,cAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,mBAFU,MAAM,CAES;IAEzB;;;OAGG;IACH,mBAFU,MAAM,CAES;IAEzB;;;;OAIG;IACH,qBAFU,MAAM,CAEW;IAE3B;;;;OAIG;IACH,WAFU,OAAO,CAEC;IAElB;;;;;;OAMG;IACH,MAFU,OAAO,CAEJ;IAEb;;;;;;;OAOG;IACH,cAFU,MAAM,CAEG;IAYnB;;;OAGG;IACH,2BAHW,QAAQ,qBAAqB,CAAC,GAC5B,IAAI,CA+ChB;IAED;;;OAGG;IACH,YAHW,qBAAqB,GACnB,IAAI,CA6ChB;IAED;;OAEG;IACH,SAFa,qBAAqB,CAMjC;IAED;;;OAGG;IACH,cAHW,qBAAqB,GACnB,OAAO,CA6CnB;IAED;;OAEG;IACH,QAFa,MAAM,CAoBlB;IAGL;;;OAGG;IACH,kCAFU,OAAO,CAEsC;CANtD;+BA5c8B,mDAAmD"}

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

@@ -16,18 +16,6 @@ export class BranchGeneratorConfig {
      */
     segments = 8;
 
-    /**
-     * Maximum radial vertices around the branch base (>= 3).
-     * @type {number}
-     */
-    radial_segments_max = 12;
-
-    /**
-     * Minimum radial vertices at the branch tip (>= 3).
-     * @type {number}
-     */
-    radial_segments_min = 4;
-
     /**
      * Nominal length in meters (scaled per child by the spawning rule's `length_profile`).
      * @type {number}
@@ -303,11 +291,6 @@ export class BranchGeneratorConfig {
             return this;
         }
         if (overrides.segments !== undefined) this.segments = Math.max(1, overrides.segments | 0);
-        if (overrides.radial_segments_max !== undefined) this.radial_segments_max = Math.max(3, overrides.radial_segments_max | 0);
-        if (overrides.radial_segments_min !== undefined) this.radial_segments_min = Math.max(3, overrides.radial_segments_min | 0);
-        if (this.radial_segments_max < this.radial_segments_min) {
-            this.radial_segments_max = this.radial_segments_min;
-        }
         if (overrides.length !== undefined) this.length = overrides.length;
         if (overrides.length_variance !== undefined) this.length_variance = overrides.length_variance;
         if (overrides.radius_ratio !== undefined) this.radius_ratio = overrides.radius_ratio;
@@ -357,8 +340,6 @@ export class BranchGeneratorConfig {
     copy(other) {
         assert.defined(other, 'other');
         this.segments = other.segments;
-        this.radial_segments_max = other.radial_segments_max;
-        this.radial_segments_min = other.radial_segments_min;
         this.length = other.length;
         this.length_variance = other.length_variance;
         this.radius_ratio = other.radius_ratio;
@@ -418,8 +399,6 @@ export class BranchGeneratorConfig {
         if (this === other) return true;
         if (!other || !other.isBranchGeneratorConfig) return false;
         return this.segments === other.segments
-            && this.radial_segments_max === other.radial_segments_max
-            && this.radial_segments_min === other.radial_segments_min
             && this.length === other.length
             && this.length_variance === other.length_variance
             && this.radius_ratio === other.radius_ratio
@@ -465,8 +444,7 @@ export class BranchGeneratorConfig {
      * @returns {number}
      */
     hash() {
-        let h = hash_mix2(this.segments, this.radial_segments_max);
-        h = hash_mix2(h, this.radial_segments_min);
+        let h = this.segments;
         h = hash_mix2(h, computeHashFloat(this.length));
         h = hash_mix2(h, computeHashFloat(this.radius_ratio));
         h = hash_mix2(h, computeHashFloat(this.taper));

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

@@ -1,11 +1,13 @@
 /**
  * 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.
+ * `tree_skeleton_grow_shoots`): how old the tree is, how fast its leader grows, 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.
+ * 158: 75-89). It rises with light: from 1, where shoots just replace themselves, at {@link compensation_light}, to the
+ * gross yield of the unit the shoot grew on at {@link saturation_light}, flat above, and below 1 in deeper shade, where a
+ * branch thins and dies. So in full light a shoot keeps every shoot its buds grow (`shoot_expected_yield`), and only
+ * shade sheds them. The defaults are chosen; each preset says where its own come from.
  */
 export class ShootGrowthConfig {
     /**
@@ -14,16 +16,39 @@ export class 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.
+     * Length (m) the leader grows a year once the tree is tall, {@link leader_unit}. It dates the framework: every
+     * branch elongates at this rate from when its parent's growth reached where it joins, so the framework 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}).
+     * How far below {@link leader_growth} a seedling's leader grows: at height 0 the leader grows `leader_growth / (1 +
+     * leader_onset)` a year (see {@link leader_unit}). 0 grows it at `leader_growth` from the first year.
      * @type {number}
      */
-    vigour: number;
+    leader_onset: number;
+    /**
+     * Height (m) over which the leader's shortfall below {@link leader_growth} falls by `e` (see {@link leader_unit}).
+     * @type {number}
+     */
+    leader_height_scale: number;
+    /**
+     * Seasons the tree grows. The framework the generator graph lays is as old as it took to grow
+     * ({@link leader_growth}); a tree older than that grows on, its framework's tips extending as shoots for the seasons
+     * left. 0 grows no longer than the framework took.
+     * @type {number}
+     */
+    age: number;
+    /**
+     * Apical control `λ` of the Borchert-Honda allocation (Borchert & Honda 1984; Palubicki et al. 2009, ACM Trans.
+     * Graph. 28(3): 58): the light a tree's shoots receive is summed down to its base and shared back up, and at each
+     * node the axis that goes on takes a share weighted `λ`, its laterals `1 - λ`. A shoot grows its demographic
+     * length times the vigour it receives per unit of its own light, relative to the most vigorous shoot's. 0.5 shares
+     * by light alone, which gives every shoot the same: the demography's lengths unchanged.
+     * @type {number}
+     */
+    apical_control: number;
     /**
      * Relative irradiance (1 under open sky) at which a shoot just replaces itself: Rb = 1.
      * @type {number}
@@ -47,11 +72,21 @@ export class ShootGrowthConfig {
      */
     light_cell: number;
     /**
-     * Net shoots a shoot leaves a year at relative irradiance `light`.
+     * Length (m) the leader of a tree `height` metres tall grows in a year: the logistic `leader_growth / (1 +
+     * leader_onset exp(-height / leader_height_scale))` by which Flower-Ellis et al. (1976) hold a young tree's height
+     * growth to its height (Kellomäki & Kurttio 1991, For. Ecol. Manage. 43: 103-123, Eq. 6).
+     * @param {number} height
+     * @returns {number}
+     */
+    leader_unit(height: number): number;
+    /**
+     * Net shoots a shoot leaves a year at relative irradiance `light`, where in full light it would keep all `gross`
+     * of the new shoots its buds grow.
      * @param {number} light
+     * @param {number} gross new shoots its buds grow a year
      * @returns {number}
      */
-    net_yield(light: number): number;
+    net_yield(light: number, gross: number): number;
     /**
      * @param {Partial<ShootGrowthConfig>} [overrides]
      * @returns {this}

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

@@ -1 +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"}
+{"version":3,"file":"ShootGrowthConfig.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/config/ShootGrowthConfig.js"],"names":[],"mappings":"AAIA;;;;;;;;;;GAUG;AACH;IA0FI;;;OAGG;IACH,sBAHW,QAAQ,iBAAiB,CAAC,GACxB,iBAAiB,CAM7B;IAjGD;;;;;OAKG;IACH,eAFU,MAAM,CAEI;IAEpB;;;;OAIG;IACH,cAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,qBAFU,MAAM,CAEQ;IAExB;;;;;OAKG;IACH,KAFU,MAAM,CAER;IAER;;;;;;;OAOG;IACH,gBAFU,MAAM,CAEK;IAErB;;;OAGG;IACH,oBAFU,MAAM,CAEU;IAE1B;;;OAGG;IACH,kBAFU,MAAM,CAEQ;IAExB;;;;OAIG;IACH,eAFU,MAAM,CAEI;IAEpB;;;;OAIG;IACH,YAFU,MAAM,CAEE;IAElB;;;;;;OAMG;IACH,oBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,iBAJW,MAAM,SACN,MAAM,GACJ,MAAM,CAMlB;IAYD;;;OAGG;IACH,2BAHW,QAAQ,iBAAiB,CAAC,GACxB,IAAI,CAgBhB;IAED;;;OAGG;IACH,YAHW,iBAAiB,GACf,IAAI,CAchB;IAED;;OAEG;IACH,SAFa,iBAAiB,CAI7B;IAED;;;OAGG;IACH,cAHW,iBAAiB,GACf,OAAO,CAcnB;IAED;;OAEG;IACH,QAFa,MAAM,CAalB;IAGL;;;OAGG;IACH,8BAFU,OAAO,CAE8B;CAN9C"}