@woosh/meep-engine 3.57.0 → 3.59.0

package/src/generation/foliage/skeleton/shoot_systems_simulate.js

@@ -10,25 +10,36 @@ import { foliage_unit_leaf_count } from "./foliage_unit_cards.js";
 import { ShootFrameworkHash } from "./ShootFrameworkHash.js";
 import { ShootGirth } from "./ShootGirth.js";
 import { ShootLightField } from "./ShootLightField.js";
-import { shoot_expected_yield, shoot_sample_unit_length } from "./shoot_demography.js";
-import { shoot_locate_on_chain, shoot_normalize3, shoot_outward3, shoot_perpendicular3, shoot_radius } from "./shoot_geometry.js";
+import { ShootWoodHash } from "./ShootWoodHash.js";
+import { shoot_expected_yield, shoot_sample_unit_length, shoot_survival } from "./shoot_demography.js";
+import { shoot_framework_buried, shoot_locate_on_chain, shoot_normalize3, shoot_perpendicular3, shoot_radius } from "./shoot_geometry.js";
 
 const GOLDEN_ANGLE = PI2 / (GOLDEN_RATIO * GOLDEN_RATIO);
 
 /**
- * Room (m) the light field leaves around the framework for the twig systems to grow into; leaf past it shades nothing
- * and sees open sky. Chosen.
+ * Room (m) the light field leaves around the wood and leaves for the shoots to grow into; a shoot past it sees open
+ * sky. The field is rebuilt round the crown when leaves come within half of it of the field's edge, so no leaf falls
+ * outside it. Chosen.
  * @type {number}
  */
 const LIGHT_FIELD_MARGIN = 2.0;
 
+/**
+ * Height (m) of the ground, the plane the surface roots creep on (`tree_skeleton_grow`): no shoot grows below it.
+ * @type {number}
+ */
+const GROUND = 0;
+
 const SCRATCH_P = new Float32Array(3);
 const SCRATCH_T = new Float32Array(3);
 const SCRATCH_R = new Float64Array(3);
 const SCRATCH_O = new Float64Array(3);
 const SCRATCH_H = new Float64Array(3);
+const SCRATCH_C = new Float64Array(3);
 const SCRATCH_A = new Float64Array(3);
 const SCRATCH_B = new Float64Array(3);
+const SCRATCH_BOX = new Float64Array(6);
+const SCRATCH_REACH = new Float64Array(1);
 
 /**
  * @typedef {Object} ShootCarrier
@@ -43,6 +54,7 @@ const SCRATCH_B = new Float64Array(3);
  * @property {number} first_season season its oldest unit grew in
  * @property {Float64Array} [carrier_area] pipe area of what grows on each unit, after the simulation
  * @property {Float64Array} [carrier_demand] radius each unit needs where its laterals join, after the simulation
+ * @property {boolean} [dead] its parent's wood has grown over it, and it and its twigs died
  */
 
 /**
@@ -61,6 +73,11 @@ const SCRATCH_B = new Float64Array(3);
  * @property {number[]} points world position of each unit boundary, `(units + 1) * 3`
  * @property {number[]} radii radius (m) of the wood at each unit boundary, `units + 1`
  * @property {number} anchor_edge carrier segment a first-order axis grows from, else -1
+ * @property {boolean} extends the carrier's own extension past its framework tip, written onto the carrier
+ */
+
+/**
+ * @typedef {ShootAxis & {alive: boolean, birth: number, heading: number[], aim: number[], taken: Array<number[]|null>, exempt_branch: number, exempt_family: number, stem: boolean, vigour: number, birth_radius: number}} ShootAxisState
  */
 
 /**
@@ -68,16 +85,22 @@ const SCRATCH_B = new Float64Array(3);
  * for `seasons` seasons: the tree's age, so every unit of every carrier has had the time since it grew to grow its
  * twigs.
  *
+ * No shoot grows into the ground, through older framework wood, or through older shoot wood (`ShootWoodHash`) it does
+ * not join: any of them is a blocked bud.
+ *
  * Each season:
  * 1. **Light.** The leaves alive last season are put in a {@link ShootLightField}, and each shoot reads the relative
  *    irradiance where it grows.
- * 2. **Extension.** Every living long axis grows a terminal unit, bent from its last by the generator's phototropism,
- *    gravitropism and zigzag, `terminal_length + terminal_length_slope *` its last unit long on average.
+ * 2. **Extension.** Every living long axis grows a terminal unit, `terminal_length + terminal_length_slope *` its last
+ *    unit long on average. The axis's course turns by the generator's phototropism (towards where the light field grows
+ *    brighter) and gravitropism, and a lateral's by its plagiotropism and straightness; the unit is kinked off that
+ *    course by the generator's zigzag.
  * 3. **Short shoots** live on at `short_shoot_survival`, less in light too dim for a shoot to replace itself.
  * 4. **Buds.** Last season's units burst their buds: by zone and mother order, a `long` share grow long shoots and a
  *    `short` share short shoots. A `sylleptic` share of this season's units' buds grow at once.
- * 5. **Shedding.** A new shoot in relative light `Q` survives at `p = net_yield(Q) / yield`. That is the species'
- *    net shoots per shoot at that light, over the gross new shoots its mother makes. Of a season's new shoots the
+ * 5. **Shedding.** A new shoot in relative light `Q` survives at `p = net_yield(Q, yield) / yield`: the species'
+ *    net shoots per shoot at that light, over the gross new shoots its mother makes from the unit it grew on
+ *    (`shoot_expected_yield`). In full light that is 1: every shoot the buds grow is kept, and only shade sheds. Of a season's new shoots the
  *    sum of their `p` survive, with a carried-over remainder so the count is exact on average. They are ranked by
  *    `log p` plus the rank of oak's shedding: the highest orders, the youngest axes and the shortest shoots go first
  *    (Buck-Sorlin & Bell 1998, Bot. J. Linn. Soc. 127: 371-391, p. 388). So the shaded go before the lit, and among
@@ -85,6 +108,14 @@ const SCRATCH_B = new Float64Array(3);
  *    everything on it, as oak sheds only at an axis's base (p. 388). So a branch in deep shade, whose terminals are
  *    shed, dies.
  *
+ * A carrier whose last annual unit grew before the last season grows on from its tip as an axis of its own order and
+ * generator, its extension: a tree older than its framework took to grow. The extension of the tree's first branch, the
+ * stem, grows each year by `ShootGrowthConfig.leader_unit` at the height its tip has reached, not by its unit before.
+ *
+ * Apical control shares the light out (`ShootGrowthConfig.apical_control`, {@link apical_vigour}): each season every
+ * new unit's mean length is scaled by its axis's vigour, and a new lateral's by its mother's. The stem keeps its
+ * height-driven leader.
+ *
  * The wood thickens season by season with what it carries (`ShootGirth`): twigs, carriers, and the framework above
  * them. A shoot whose path would run into framework wood as thick as it is that season is a blocked bud and does not
  * grow; its mother's junction is the one exception. A blocked terminal leaves its axis without a unit that season. A
@@ -105,7 +136,6 @@ export function shoot_systems_simulate(skeleton, species, carriers, seasons, rng
     const girth = new ShootGirth(skeleton, carriers, skeleton.branch_count, species.crown.pipe_model_exponent);
     let framework = new ShootFrameworkHash(skeleton, framework_segments);
     const leaf_survival = species.foliage.leaf_survival;
-    const yields = carriers.map(c => shoot_expected_yield(c.rule));
 
     // Leaf area of one leaf, as the cards draw it
     const leafy = new Map();
@@ -119,15 +149,142 @@ export function shoot_systems_simulate(skeleton, species, carriers, seasons, rng
         leaf_area_each = foliage_card_leaf_area(layout, species.foliage.card_type, coverage, 1.0) / layout.leaves_per_card;
     }
 
-    const field = make_light_field(skeleton, growth.light_cell);
+    const bounds = framework_bounds(skeleton);
+    let field = make_light_field(bounds, growth.light_cell);
 
-    /** @type {Array<ShootAxis & {alive: boolean, birth: number, heading: number[], taken: Array<number[]|null>, exempt_branch: number, key: number}>} */
+    /** @type {ShootAxisState[]} */
     const axes = [];
     /** buds spent on sylleptic shoots per carrier unit, by zone */
     const carrier_taken = carriers.map(c => new Array(c.units.length).fill(null));
+    // the shoots' own wood, every unit once it has grown
+    const wood = new ShootWoodHash(axes);
+    // the shoot a query is for: its mother (-1 for a carrier), the unit it grows from, its carrier, itself (-1 before it
+    // exists), its unit being tested and that unit's radius
+    let probe_parent = -1, probe_parent_unit = 0, probe_system = 0, probe_self = -1, probe_unit = 0;
+    // the probe unit's radii at its ends, and where along it the capsule tested starts
+    let probe_r0 = 0, probe_r1 = 0, probe_s0 = 0;
+    /**
+     * Whether unit `k` of lateral `child` (-1 for one not grown yet, at its junction) is in its crotch: it starts inside
+     * its mother's wood where it grew, however far her girth carries it: nearer the axis of her unit there, or of the
+     * one either side, than her radius. With `k` past the last unit, whether its tip is.
+     */
+    const in_crotch = (child, k) => {
+        if (child < 0 || k === 0) return true;
+        return wood_reach(child, k) < 0;
+    };
+    /**
+     * How far point `k` of lateral `child` lies outside its mother's wood where it grew, on her unit there or the one
+     * either side (negative inside), into `reach_distance` its distance from her axis.
+     */
+    let reach_distance = 0;
+    const wood_reach = (child, k) => {
+        const axis = axes[child];
+        const p = axis.points;
+        const q = k * 3;
+        let best = Infinity;
+        if (axis.parent >= 0) {
+            const mother = axes[axis.parent];
+            const m = mother.points;
+            for (let j = Math.max(0, axis.parent_unit - 1); j <= Math.min(mother.units.length - 1, axis.parent_unit + 1); j++) {
+                const a = j * 3;
+                const out = outside_wood(p, q, m[a], m[a + 1], m[a + 2], m[a + 3], m[a + 4], m[a + 5],
+                    ShootWoodHash.radius_at(mother, j, 0), ShootWoodHash.radius_at(mother, j, 1));
+                if (out < best) {
+                    best = out;
+                    reach_distance = SCRATCH_REACH[0];
+                }
+            }
+            return best;
+        }
+        const edges = carriers[axis.system].edges;
+        const at = edges.indexOf(axis.anchor_edge);
+        for (let j = Math.max(0, at - 1); j <= Math.min(edges.length - 1, at + 1); j++) {
+            const v0 = skeleton.segment_v0(edges[j]), v1 = skeleton.segment_v1(edges[j]);
+            skeleton.node_read_position(SCRATCH_P, 0, v0);
+            skeleton.node_read_position(SCRATCH_T, 0, v1);
+            const out = outside_wood(p, q, SCRATCH_P[0], SCRATCH_P[1], SCRATCH_P[2], SCRATCH_T[0], SCRATCH_T[1], SCRATCH_T[2],
+                skeleton.node_read_radius(v0), skeleton.node_read_radius(v1));
+            if (out < best) {
+                best = out;
+                reach_distance = SCRATCH_REACH[0];
+            }
+        }
+        return best;
+    };
+    /**
+     * Whether unit `k` of axis `m` is one wood with the probe's unit where they join: the same axis; a mother, either
+     * side of where her lateral grew and anywhere over its crotch; a grandmother where it grew at its mother's base; a
+     * carrier's extension, which is the carrier, and the carrier's laterals by the tip it grew from. Shoots from the same
+     * node share only their collar, which the first unit's test leaves out ({@link collar_start}).
+     */
+    const joined = (m, k) => {
+        if (m === probe_self) return true;
+        const other = axes[m];
+        // the other is the probe's mother or grandmother
+        if (m === probe_parent) return Math.abs(k - probe_parent_unit) <= 1 || in_crotch(probe_self, probe_unit);
+        if (probe_parent >= 0 && probe_parent_unit <= 1 && axes[probe_parent].parent === m) {
+            return Math.abs(k - axes[probe_parent].parent_unit) <= 1;
+        }
+        // the probe is the other's mother or grandmother
+        if (probe_self >= 0 && other.parent === probe_self) return Math.abs(probe_unit - other.parent_unit) <= 1 || in_crotch(m, k);
+        if (probe_self >= 0 && other.parent >= 0 && other.parent_unit <= 1 && axes[other.parent].parent === probe_self) {
+            return Math.abs(probe_unit - axes[other.parent].parent_unit) <= 1;
+        }
+        // a carrier's extension and the carrier's laterals by its tip
+        if (probe_parent < 0 && other.parent < 0 && other.system === probe_system) {
+            if (other.extends) return k <= 1 && probe_parent_unit >= other.parent_unit - 1;
+            if (probe_self >= 0 && axes[probe_self].extends) return probe_unit <= 1 && other.parent_unit >= probe_parent_unit - 1;
+        }
+        return false;
+    };
+    /**
+     * Where along its first unit, `len` long, a lateral leaves the collar it shares with its siblings: out of its
+     * mother's wood, `mother_radius` thick, and at least half way.
+     * @param {number} len
+     * @param {number} mother_radius
+     * @returns {number}
+     */
+    const collar_start = (len, mother_radius) => Math.max(0.5, Math.min(1, mother_radius / Math.max(1e-9, len)));
+    /** Radius (m) of the wood lateral `axis` grew from, where it grew */
+    const junction_radius = (axis) => {
+        if (axis.parent >= 0) {
+            const mother = axes[axis.parent];
+            return Math.max(ShootWoodHash.radius_at(mother, axis.parent_unit, 0), ShootWoodHash.radius_at(mother, axis.parent_unit, 1));
+        }
+        const e = axis.anchor_edge;
+        return Math.max(skeleton.node_read_radius(skeleton.segment_v0(e)), skeleton.node_read_radius(skeleton.segment_v1(e)));
+    };
+    /** Whether axis `m` grew from the probe's node or the next: their first units share a collar */
+    const sibling = (m) => {
+        const other = axes[m];
+        return other.parent === probe_parent && (probe_parent >= 0 || other.system === probe_system)
+            && Math.abs(other.parent_unit - probe_parent_unit) <= 1;
+    };
+    /** Wood the probe's whole unit is tested against, and its siblings' first units only out of its collar */
+    const skip_joined = (m, k) => joined(m, k) || (k === 0 && sibling(m));
+    const skip_joined_out_of_collar = (m, k) => joined(m, k);
+    /**
+     * Wood has grown into the probe's unit, whose line it holds, if they are not joined and, where they meet, it is
+     * thicker than the probe, or as thick and older
+     */
+    const thinner = (m, r, s) => {
+        const at = probe_s0 + (1 - probe_s0) * s;
+        const own = probe_r0 + (probe_r1 - probe_r0) * at;
+        return r < own || (r === own && m > probe_self);
+    };
+    const skip_engulf = (m, k, r, s) => joined(m, k) || (k === 0 && sibling(m)) || thinner(m, r, s);
+    const skip_engulf_out_of_collar = (m, k, r, s) => joined(m, k) || thinner(m, r, s);
+
+    /** vigour per unit of light of each carrier's base, relative to the most vigorous shoot's */
+    const carrier_vigour = new Float64Array(carriers.length).fill(1);
     let remainder = 0.5;
 
-    const survival_at = (light, system) => clamp(growth.net_yield(light) / yields[system], 0, 1);
+    /**
+     * A new shoot's chance in `light`: the net shoots a shoot leaves, over the gross new shoots its mother makes, a unit
+     * of `mother_order` `mother_length` metres long; 1 in full light
+     */
+    const survival_at = (light, system, mother_order, mother_length) =>
+        shoot_survival(growth, light, shoot_expected_yield(carriers[system].rule, mother_order, mother_length));
 
     /**
      * Where a bud on unit `k` of a mother sits, and the mother's tangent there, into SCRATCH_P / SCRATCH_T.
@@ -153,16 +310,22 @@ export function shoot_systems_simulate(skeleton, species, carriers, seasons, rng
 
     /**
      * A lateral from bud `node` at `u` on unit `k` of `mother` (`-1` for the carrier), or -1 when the bud cannot grow:
-     * knocked out on a plagiotropic mother, or blocked by framework wood.
+     * its generator bears no leaves (no foliage rule), or no bud round its node clears a plagiotropic mother's ventral
+     * cone, the ground, and older wood.
      */
     const spawn = (system, mother, k, u, node, order, mean_length, short, season, candidates) => {
         const c = carriers[system];
         const rule = c.rule;
+        // a shoot pays for its offspring with its leaves: one of a generator that bears none yields nothing
+        const generator = short ? rule.short_target : shoot_order_value(rule.target, order - 1);
+        if (!leafy.has(generator)) return -1;
         const located = bud_site(system, mother, k, u);
         const px = SCRATCH_P[0], py = SCRATCH_P[1], pz = SCRATCH_P[2];
         const mtx = SCRATCH_T[0], mty = SCRATCH_T[1], mtz = SCRATCH_T[2];
         const mother_phase = mother < 0 ? skeleton.branch_phase_hash[c.carrier] : axes[mother].phase;
         const mother_generator = mother < 0 ? rule.source : axes[mother].generator;
+        // a trunk is upright: it has no horizontal plane to fan its buds into, so no ventral knockout
+        const mother_trunk = mother < 0 ? skeleton.branch_parent[c.carrier] < 0 : axes[mother].stem;
 
         // radial direction at the bud: a frame around the mother's tangent turned by the leaf spiral
         shoot_perpendicular3(SCRATCH_R, mtx, mty, mtz);
@@ -172,57 +335,73 @@ export function shoot_systems_simulate(skeleton, species, carriers, seasons, rng
         const sz0 = mtx * ry0 - mty * rx0;
         const ins = shoot_order_value(rule.insertion_angle, order - 1) * (0.85 + 0.3 * rng());
         const cos_i = Math.cos(ins), sin_i = Math.sin(ins);
-        // a plagiotropic mother breaks no bud into the downward cone (its ventral knockout): the bud turns by the golden
-        // angle until it clears it, or does not break
-        const plagio = species.branches[mother_generator].plagiotropism;
+        const vigour = mother < 0 ? carrier_vigour[system] : axes[mother].vigour;
+        const len = short ? rule.short_shoot_growth : shoot_sample_unit_length(rng, mean_length * vigour, order, rule);
+        const radius = shoot_radius(len, 0);
+        const exempt_branch = mother < 0 ? c.carrier : -1;
+        const exempt_edge = located !== null ? located.edge : -1;
+        probe_parent = mother;
+        probe_parent_unit = k;
+        probe_system = system;
+        probe_self = -1;
+        probe_unit = 0;
+        const mother_radius = located !== null
+            ? Math.max(skeleton.node_read_radius(skeleton.segment_v0(located.edge)), skeleton.node_read_radius(skeleton.segment_v1(located.edge)))
+            : Math.max(ShootWoodHash.radius_at(axes[mother], k, 0), ShootWoodHash.radius_at(axes[mother], k, 1));
+        const collar = collar_start(len, mother_radius) * len;
+        // a bud breaks where there is room: not into a plagiotropic mother's downward cone (its ventral knockout), the
+        // ground, or wood that was there first, its own junction aside. Blocked, it turns by the golden angle round its
+        // node to where the next bud would be, or does not break
+        const plagio = mother_trunk ? 0 : species.branches[mother_generator].plagiotropism;
         const ventral_cos = plagio > 0 ? Math.cos(plagio * Math.PI * 0.5) : Infinity;
         let phi = phyllotaxis_sample_angle(rule.phyllotaxis_mode, node, 1, mother_phase * PI2) + (rng() - 0.5) * 0.4;
-        let tx = 0, ty = 0, tz = 0;
         let cleared = false;
         for (let attempt = 0; attempt < 5 && !cleared; attempt++, phi += GOLDEN_ANGLE) {
             const drx = Math.cos(phi) * rx0 + Math.sin(phi) * sx0;
             const dry = Math.cos(phi) * ry0 + Math.sin(phi) * sy0;
             const drz = Math.cos(phi) * rz0 + Math.sin(phi) * sz0;
-            tx = cos_i * mtx + sin_i * drx;
-            ty = cos_i * mty + sin_i * dry;
-            tz = cos_i * mtz + sin_i * drz;
-            cleared = -ty / Math.max(1e-9, Math.hypot(tx, ty, tz)) <= ventral_cos;
+            shoot_normalize3(SCRATCH_H, cos_i * mtx + sin_i * drx, cos_i * mty + sin_i * dry, cos_i * mtz + sin_i * drz);
+            if (-SCRATCH_H[1] > ventral_cos) continue;
+            SCRATCH_B[0] = px + SCRATCH_H[0] * len;
+            SCRATCH_B[1] = py + SCRATCH_H[1] * len;
+            SCRATCH_B[2] = pz + SCRATCH_H[2] * len;
+            SCRATCH_A[0] = px;
+            SCRATCH_A[1] = py;
+            SCRATCH_A[2] = pz;
+            if (SCRATCH_B[1] < GROUND || framework.hits(SCRATCH_A, SCRATCH_B, radius, exempt_branch, exempt_edge)) continue;
+            if (wood.hits(SCRATCH_A, SCRATCH_B, radius, 0, skip_joined) >= 0) continue;
+            SCRATCH_A[0] = px + SCRATCH_H[0] * collar;
+            SCRATCH_A[1] = py + SCRATCH_H[1] * collar;
+            SCRATCH_A[2] = pz + SCRATCH_H[2] * collar;
+            cleared = wood.hits(SCRATCH_A, SCRATCH_B, radius, 0, skip_joined_out_of_collar) < 0;
         }
         if (!cleared) return -1;
-        shoot_normalize3(SCRATCH_H, tx, ty, tz);
-
-        const len = short ? rule.short_shoot_growth : shoot_sample_unit_length(rng, mean_length, order, rule);
-        SCRATCH_A[0] = px;
-        SCRATCH_A[1] = py;
-        SCRATCH_A[2] = pz;
-        SCRATCH_B[0] = px + SCRATCH_H[0] * len;
-        SCRATCH_B[1] = py + SCRATCH_H[1] * len;
-        SCRATCH_B[2] = pz + SCRATCH_H[2] * len;
-        const exempt_branch = mother < 0 ? c.carrier : -1;
-        const exempt_edge = located !== null ? located.edge : -1;
-        // a shoot does not grow through wood that was there first, its own junction aside
-        if (framework.hits(SCRATCH_A, SCRATCH_B, shoot_radius(len, 0), exempt_branch, exempt_edge)) return -1;
 
         const light = field.irradiance_at(px, py, pz);
         axes.push({
             system, parent: mother, parent_unit: k, u, node, order, short,
-            generator: short ? rule.short_target : rule.target,
+            generator,
             phase: rng(),
             units: [len],
             unit_seasons: [season],
             points: [px, py, pz, SCRATCH_B[0], SCRATCH_B[1], SCRATCH_B[2]],
             radii: [],
             anchor_edge: located !== null ? located.edge : -1,
+            extends: false,
             exempt_branch,
+            exempt_family: -1,
+            stem: false,
+            vigour,
+            birth_radius: mother_radius,
             heading: [SCRATCH_H[0], SCRATCH_H[1], SCRATCH_H[2]],
+            aim: [SCRATCH_H[0], SCRATCH_H[1], SCRATCH_H[2]],
             taken: [null],
             birth: season,
-            alive: true,
-            key: 0
+            alive: true
         });
         const m = axes.length - 1;
         if (!short) {
-            const p = survival_at(light, system);
+            const p = survival_at(light, system, order - 1, mother < 0 ? c.units[k] : axes[mother].units[k]);
             candidates.push({ axis: m, p, key: shed_rank(p, order, len, 0, rule, rng) });
             axes[m].taken[0] = sylleptic(system, m, 0, len, order, season, candidates);
         }
@@ -289,7 +468,12 @@ export function shoot_systems_simulate(skeleton, species, carriers, seasons, rng
 
     for (let season = 0; season < seasons; season++) {
         // 1. Light from last season's leaves
+        crown_frame(skeleton, carriers, axes);
         if (season > 0) {
+            crown_bounds(bounds, carriers, axes);
+            if (!field_holds(field, bounds)) {
+                field = make_light_field(bounds, growth.light_cell);
+            }
             field.clear();
             deposit_leaves(field, species, carriers, axes, season - 1, leafy, leaf_area_each, leaf_survival);
             field.solve(growth.leaf_clumping);
@@ -298,6 +482,17 @@ export function shoot_systems_simulate(skeleton, species, carriers, seasons, rng
         /** @type {Array<{axis: number, p: number, key: number}>} key: the shedding rank, the highest kept */
         const candidates = [];
 
+        // a carrier whose last unit grew last season grows on from its tip from now
+        for (let s = 0; s < carriers.length; s++) {
+            const c = carriers[s];
+            if (!c.dead && season === c.first_season + c.units.length) {
+                axes.push(carrier_extension(skeleton, c, s, season));
+            }
+        }
+
+        // the light the shoots receive flows down and back up: each axis's vigour
+        apical_vigour(axes, carriers, field, growth.apical_control, carrier_vigour);
+
         // 2. Every living long axis extends by a terminal unit, a candidate for shedding with its whole axis
         const extended = [];
         const count_before = axes.length;
@@ -310,17 +505,33 @@ export function shoot_systems_simulate(skeleton, species, carriers, seasons, rng
             const pts = axis.points;
             const tip = n * 3;
             const light = field.irradiance_at(pts[tip], pts[tip + 1], pts[tip + 2]);
-            shoot_outward3(SCRATCH_O, skeleton, pts[tip], pts[tip + 1], pts[tip + 2]);
+            const c = carriers[axis.system];
+            field.gradient_at(SCRATCH_O, pts[tip], pts[tip + 1], pts[tip + 2]);
+            // the axis's course turns by its tropisms; a lateral's also towards the horizontal by its plagiotropism and back
+            // towards its bud's heading by its straightness, as the graph's spines do (a trunk takes neither). The
+            // internode's zigzag kinks this unit off the course, not the course
             const zig = cfg.internode_zigzag;
             const h = axis.heading;
+            const aim = axis.aim;
+            const plagio = axis.stem ? 0 : cfg.plagiotropism;
+            const straight = axis.stem ? 0 : cfg.straightness;
+            shoot_normalize3(
+                SCRATCH_C,
+                h[0] + cfg.phototropism * 0.5 * SCRATCH_O[0] + straight * 0.5 * (aim[0] - h[0]),
+                h[1] + cfg.phototropism * 0.5 * SCRATCH_O[1] - cfg.gravitropism * 0.5 - plagio * 0.5 * h[1] + straight * 0.5 * (aim[1] - h[1]),
+                h[2] + cfg.phototropism * 0.5 * SCRATCH_O[2] + straight * 0.5 * (aim[2] - h[2])
+            );
             shoot_normalize3(
                 SCRATCH_H,
-                h[0] + cfg.phototropism * 0.5 * SCRATCH_O[0] + (rng() * 2 - 1) * zig,
-                h[1] + cfg.phototropism * 0.5 * SCRATCH_O[1] - cfg.gravitropism * 0.5 + (rng() * 2 - 1) * zig,
-                h[2] + cfg.phototropism * 0.5 * SCRATCH_O[2] + (rng() * 2 - 1) * zig
+                SCRATCH_C[0] + (rng() * 2 - 1) * zig,
+                SCRATCH_C[1] + (rng() * 2 - 1) * zig,
+                SCRATCH_C[2] + (rng() * 2 - 1) * zig
             );
-            const prev = axis.units[n - 1];
-            const mean = shoot_order_value(rule.terminal_length, axis.order) + shoot_order_value(rule.terminal_length_slope, axis.order) * prev;
+            const prev = n > 0 ? axis.units[n - 1] : c.units[c.units.length - 1];
+            // the stem grows as fast as the tree's height lets it; every other axis by its unit before
+            const mean = axis.stem
+                ? growth.leader_unit(pts[tip + 1])
+                : axis.vigour * (shoot_order_value(rule.terminal_length, axis.order) + shoot_order_value(rule.terminal_length_slope, axis.order) * prev);
             const len = shoot_sample_unit_length(rng, mean, axis.order, rule);
             SCRATCH_A[0] = pts[tip];
             SCRATCH_A[1] = pts[tip + 1];
@@ -328,15 +539,21 @@ export function shoot_systems_simulate(skeleton, species, carriers, seasons, rng
             SCRATCH_B[0] = pts[tip] + SCRATCH_H[0] * len;
             SCRATCH_B[1] = pts[tip + 1] + SCRATCH_H[1] * len;
             SCRATCH_B[2] = pts[tip + 2] + SCRATCH_H[2] * len;
-            if (framework.hits(SCRATCH_A, SCRATCH_B, shoot_radius(len, 0), axis.exempt_branch, axis.anchor_edge)) continue;
+            if (SCRATCH_B[1] < GROUND || framework.hits(SCRATCH_A, SCRATCH_B, shoot_radius(len, 0), axis.exempt_branch, axis.anchor_edge, axis.exempt_family)) continue;
+            probe_parent = axis.parent;
+            probe_parent_unit = axis.parent_unit;
+            probe_system = axis.system;
+            probe_self = m;
+            probe_unit = n;
+            if (wood.hits(SCRATCH_A, SCRATCH_B, shoot_radius(len, 0), 0, skip_joined_out_of_collar) >= 0) continue;
             axis.units.push(len);
             axis.unit_seasons.push(season);
             axis.taken.push(null);
             pts.push(SCRATCH_B[0], SCRATCH_B[1], SCRATCH_B[2]);
-            h[0] = SCRATCH_H[0];
-            h[1] = SCRATCH_H[1];
-            h[2] = SCRATCH_H[2];
-            const p_ext = survival_at(light, axis.system);
+            h[0] = SCRATCH_C[0];
+            h[1] = SCRATCH_C[1];
+            h[2] = SCRATCH_C[2];
+            const p_ext = survival_at(light, axis.system, axis.order, prev);
             candidates.push({ axis: m, p: p_ext, key: shed_rank(p_ext, axis.order, len, season - axis.birth, rule, rng) });
             extended.push(m);
         }
@@ -349,7 +566,10 @@ export function shoot_systems_simulate(skeleton, species, carriers, seasons, rng
             const pts = axis.points;
             const tip = axis.units.length * 3;
             const light = field.irradiance_at(pts[tip], pts[tip + 1], pts[tip + 2]);
-            if (rng() < rule.short_shoot_survival * Math.min(1, growth.net_yield(light))) {
+            // a shoot that cannot replace itself, below the compensation light, dies the more the darker
+            const mother_unit = axis.parent < 0 ? carriers[axis.system].units[axis.parent_unit] : axes[axis.parent].units[axis.parent_unit];
+            const gross = shoot_expected_yield(rule, axis.order - 1, mother_unit);
+            if (rng() < rule.short_shoot_survival * Math.min(1, growth.net_yield(light, gross))) {
                 const g = rule.short_shoot_growth;
                 axis.units.push(g);
                 axis.unit_seasons.push(season);
@@ -363,7 +583,7 @@ export function shoot_systems_simulate(skeleton, species, carriers, seasons, rng
         for (let s = 0; s < carriers.length; s++) {
             const c = carriers[s];
             const k = season - 1 - c.first_season;
-            if (k >= 0 && k < c.units.length) {
+            if (!c.dead && k >= 0 && k < c.units.length) {
                 burst(s, -1, k, c.units[k], c.rule.carrier_order, carrier_taken[s][k], season, candidates);
             }
         }
@@ -380,7 +600,7 @@ export function shoot_systems_simulate(skeleton, species, carriers, seasons, rng
         for (let s = 0; s < carriers.length; s++) {
             const c = carriers[s];
             const k = season - c.first_season;
-            if (k >= 0 && k < c.units.length) {
+            if (!c.dead && k >= 0 && k < c.units.length) {
                 carrier_taken[s][k] = sylleptic(s, -1, k, c.units[k], c.rule.carrier_order, season, candidates);
             }
         }
@@ -403,18 +623,37 @@ export function shoot_systems_simulate(skeleton, species, carriers, seasons, rng
         // a dead mother takes everything on it; mothers come first
         cascade(axes);
 
-        // 7. The wood thickens with what it now carries, and what it has grown into dies
+        // 7. The wood thickens with what it now carries, and what it has grown into dies: framework wood, or shoot wood
+        // thicker than it, or as thick and older. This season's units join the shoots' wood
         girth.update(axes, season);
         framework = new ShootFrameworkHash(skeleton, framework_segments);
+        // a carrier its parent's thickening wood has grown over dies, with its twigs
+        for (const c of carriers) {
+            if (!c.dead && shoot_framework_buried(skeleton, c.carrier)) c.dead = true;
+        }
+        for (let m = 0; m < axes.length; m++) {
+            const axis = axes[m];
+            if (!axis.alive || axis.short) continue;
+            for (let k = 0; k < axis.units.length; k++) {
+                if (axis.unit_seasons[k] === season) wood.add(m, k);
+            }
+        }
+        wood.refresh();
         for (let m = 0; m < axes.length; m++) {
             const axis = axes[m];
             if (!axis.alive) continue;
-            if (axis.parent >= 0 && !axes[axis.parent].alive) {
+            if ((axis.parent >= 0 && !axes[axis.parent].alive) || carriers[axis.system].dead) {
                 axis.alive = false;
                 continue;
             }
             const pts = axis.points;
             const r = axis.radii;
+            // a lateral whose tip the wood its mother grew since has closed over is buried (one that grew out of wood
+            // already there, as on a carrier the generator graph laid at its full girth, is not)
+            if (!axis.extends && !axis.short && wood_reach(m, axis.units.length) < 0 && reach_distance >= axis.birth_radius) {
+                axis.alive = false;
+                continue;
+            }
             for (let k = 0; k < axis.units.length; k++) {
                 SCRATCH_A[0] = pts[k * 3];
                 SCRATCH_A[1] = pts[k * 3 + 1];
@@ -422,10 +661,36 @@ export function shoot_systems_simulate(skeleton, species, carriers, seasons, rng
                 SCRATCH_B[0] = pts[k * 3 + 3];
                 SCRATCH_B[1] = pts[k * 3 + 4];
                 SCRATCH_B[2] = pts[k * 3 + 5];
-                if (framework.hits(SCRATCH_A, SCRATCH_B, Math.max(r[k], r[k + 1]), axis.exempt_branch, axis.anchor_edge)) {
+                if (framework.hits(SCRATCH_A, SCRATCH_B, Math.max(r[k], r[k + 1]), axis.exempt_branch, axis.anchor_edge, axis.exempt_family)) {
+                    axis.alive = false;
+                    break;
+                }
+                if (axis.short) continue;
+                probe_parent = axis.parent;
+                probe_parent_unit = axis.parent_unit;
+                probe_system = axis.system;
+                probe_self = m;
+                probe_unit = k;
+                probe_r0 = r[k];
+                probe_r1 = r[k + 1];
+                probe_s0 = 0;
+                const thinnest = Math.min(r[k], r[k + 1]);
+                // grown into: the unit's line is inside the other wood, not merely its bark against it; a first unit's
+                // siblings only out of the collar they share
+                if (wood.hits(SCRATCH_A, SCRATCH_B, 0, thinnest, k === 0 ? skip_engulf : skip_engulf_out_of_collar) >= 0) {
                     axis.alive = false;
                     break;
                 }
+                if (k === 0 && !axis.extends) {
+                    probe_s0 = collar_start(axis.units[0], junction_radius(axis));
+                    SCRATCH_A[0] += (SCRATCH_B[0] - SCRATCH_A[0]) * probe_s0;
+                    SCRATCH_A[1] += (SCRATCH_B[1] - SCRATCH_A[1]) * probe_s0;
+                    SCRATCH_A[2] += (SCRATCH_B[2] - SCRATCH_A[2]) * probe_s0;
+                    if (wood.hits(SCRATCH_A, SCRATCH_B, 0, thinnest, skip_engulf_out_of_collar) >= 0) {
+                        axis.alive = false;
+                        break;
+                    }
+                }
             }
         }
     }
@@ -436,7 +701,8 @@ export function shoot_systems_simulate(skeleton, species, carriers, seasons, rng
     const living = [];
     for (let m = 0; m < axes.length; m++) {
         const axis = axes[m];
-        if (!axis.alive) continue;
+        // an extension blocked since it began has no unit
+        if (!axis.alive || axis.units.length === 0) continue;
         index[m] = living.length;
         living.push({
             system: axis.system,
@@ -452,12 +718,163 @@ export function shoot_systems_simulate(skeleton, species, carriers, seasons, rng
             unit_seasons: axis.unit_seasons,
             points: axis.points,
             radii: axis.radii,
-            anchor_edge: axis.anchor_edge
+            anchor_edge: axis.anchor_edge,
+            extends: axis.extends
         });
     }
     return living;
 }
 
+/**
+ * Borchert-Honda allocation of the light the shoots receive (Borchert & Honda 1984, as Palubicki et al. 2009, ACM
+ * Trans. Graph. 28(3): 58, use it). Each living axis receives the relative irradiance at its tip; summed down every
+ * subtree, each carrier's total flows back up from its base, and at each lateral, base first, the lateral takes
+ * `v (1 - λ) Q_l / (λ Q_rest + (1 - λ) Q_l)` of the flow `v`, `Q_l` its subtree's light and `Q_rest` the light of the
+ * axis beyond it. What reaches an axis's tip over its own light is its vigour, which is written relative to the most
+ * vigorous axis's into `axis.vigour`; a carrier's base receives its subtree's light, vigour 1 before that division.
+ * At `λ = 0.5` every vigour is 1.
+ *
+ * @param {ShootAxisState[]} axes
+ * @param {ShootCarrier[]} carriers
+ * @param {ShootLightField} field
+ * @param {number} lambda
+ * @param {Float64Array} carrier_vigour out
+ */
+function apical_vigour(axes, carriers, field, lambda, carrier_vigour) {
+    const n = axes.length;
+    const own = new Float64Array(n);
+    const sub = new Float64Array(n);
+    const flow = new Float64Array(n);
+    /** @type {Array<number[]|undefined>} */
+    const children = new Array(n);
+    const carrier_children = carriers.map(() => []);
+    for (let m = 0; m < n; m++) {
+        const axis = axes[m];
+        if (!axis.alive) continue;
+        const p = axis.points;
+        const t = axis.units.length * 3;
+        own[m] = field.irradiance_at(p[t], p[t + 1], p[t + 2]);
+        if (axis.parent < 0) {
+            carrier_children[axis.system].push(m);
+        } else if (axes[axis.parent].alive) {
+            (children[axis.parent] ??= []).push(m);
+        }
+    }
+    // laterals come after their mother: their light is summed into hers first
+    for (let m = n - 1; m >= 0; m--) {
+        if (!axes[m].alive) continue;
+        sub[m] += own[m];
+        const parent = axes[m].parent;
+        if (parent >= 0) sub[parent] += sub[m];
+    }
+    const by_site = (a, b) => (axes[a].parent_unit - axes[b].parent_unit) || (axes[a].u - axes[b].u);
+    // shares flow `v` entering an axis of own light `own_light` among its laterals, base first; returns what reaches its tip
+    const share = (v, own_light, kids) => {
+        kids.sort(by_site);
+        let rest = own_light;
+        for (let i = 0; i < kids.length; i++) rest += sub[kids[i]];
+        for (let i = 0; i < kids.length; i++) {
+            const c = kids[i];
+            const q = sub[c];
+            rest -= q;
+            const d = lambda * rest + (1 - lambda) * q;
+            const vc = d > 0 ? v * (1 - lambda) * q / d : 0;
+            flow[c] = vc;
+            v -= vc;
+        }
+        return v;
+    };
+    for (let s = 0; s < carriers.length; s++) {
+        const kids = carrier_children[s];
+        let total = 0;
+        for (let i = 0; i < kids.length; i++) total += sub[kids[i]];
+        share(total, 0, kids);
+    }
+    let most = 1;
+    for (let m = 0; m < n; m++) {
+        const axis = axes[m];
+        if (!axis.alive) continue;
+        const tip = share(flow[m], own[m], children[m] ?? []);
+        axis.vigour = own[m] > 0 ? tip / own[m] : 0;
+        if (axis.vigour > most) most = axis.vigour;
+    }
+    for (let m = 0; m < n; m++) {
+        if (axes[m].alive) axes[m].vigour /= most;
+    }
+    carrier_vigour.fill(1 / most);
+}
+
+/**
+ * Carrier `c`'s own extension from its tip from `season` on: an axis of the carrier's order and generator, heading
+ * along the carrier's tip, with no unit yet. It counts as grown a season before, so it extends with the living axes; it
+ * keeps clear of no wood of the carrier or of what the carrier carries in the framework.
+ *
+ * @param {import("./TreeSkeleton.js").TreeSkeleton} skeleton
+ * @param {ShootCarrier} c
+ * @param {number} system
+ * @param {number} season
+ */
+function carrier_extension(skeleton, c, system, season) {
+    const last = c.units.length;
+    const edge = c.edges[c.edges.length - 1];
+    skeleton.evaluate_segment_tangent(SCRATCH_T, 0, edge, 1);
+    shoot_normalize3(SCRATCH_H, SCRATCH_T[0], SCRATCH_T[1], SCRATCH_T[2]);
+    return {
+        system, parent: -1, parent_unit: last - 1, u: 1, node: 0,
+        order: c.rule.carrier_order,
+        short: false,
+        generator: c.rule.source,
+        phase: skeleton.branch_phase_hash[c.carrier],
+        units: [],
+        unit_seasons: [],
+        points: [c.points[last * 3], c.points[last * 3 + 1], c.points[last * 3 + 2]],
+        radii: [],
+        anchor_edge: edge,
+        extends: true,
+        exempt_branch: c.carrier,
+        exempt_family: c.carrier,
+        stem: skeleton.branch_parent[c.carrier] < 0,
+        vigour: 1,
+        birth_radius: 0,
+        heading: [SCRATCH_H[0], SCRATCH_H[1], SCRATCH_H[2]],
+        aim: [SCRATCH_H[0], SCRATCH_H[1], SCRATCH_H[2]],
+        taken: [],
+        birth: season - 1,
+        alive: true
+    };
+}
+
+/**
+ * Centres the skeleton's crown frame, which the foliage and the crown's shading read, on the carriers and the living
+ * axes, and spans it over them.
+ * @param {import("./TreeSkeleton.js").TreeSkeleton} skeleton
+ * @param {ShootCarrier[]} carriers
+ * @param {Array<{alive: boolean, points: number[]}>} axes
+ */
+function crown_frame(skeleton, carriers, axes) {
+    const box = SCRATCH_BOX;
+    box[0] = box[1] = box[2] = Infinity;
+    box[3] = box[4] = box[5] = -Infinity;
+    crown_bounds(box, carriers, axes);
+    for (let i = 0; i < 3; i++) {
+        skeleton.crown_center[i] = 0.5 * (box[i] + box[i + 3]);
+        skeleton.crown_radii[i] = Math.max(0.25, 0.5 * (box[i + 3] - box[i]));
+    }
+}
+
+/**
+ * How far point `q` of `p` lies outside the wood of the segment from `(x0, y0, z0)`, radius `r0`, to `(x1, y1, z1)`,
+ * radius `r1` (negative inside); its distance from the segment's axis into `SCRATCH_REACH[0]`.
+ * @returns {number}
+ */
+function outside_wood(p, q, x0, y0, z0, x1, y1, z1, r0, r1) {
+    const dx = x1 - x0, dy = y1 - y0, dz = z1 - z0;
+    const t = clamp(((p[q] - x0) * dx + (p[q + 1] - y0) * dy + (p[q + 2] - z0) * dz) / Math.max(1e-12, dx * dx + dy * dy + dz * dz), 0, 1);
+    const d = Math.hypot(p[q] - x0 - dx * t, p[q + 1] - y0 - dy * t, p[q + 2] - z0 - dz * t);
+    SCRATCH_REACH[0] = d;
+    return d - (r0 + (r1 - r0) * t);
+}
+
 /**
  * Kills every axis whose mother has died; mothers come before their laterals.
  * @param {Array<{parent: number, alive: boolean}>} axes
@@ -470,26 +887,76 @@ function cascade(axes) {
 }
 
 /**
- * A light field over the framework and {@link LIGHT_FIELD_MARGIN} around it.
+ * The box `[min x, y, z, max x, y, z]` round the framework's nodes.
  * @param {import("./TreeSkeleton.js").TreeSkeleton} skeleton
- * @param {number} cell
- * @returns {ShootLightField}
+ * @returns {Float64Array}
  */
-function make_light_field(skeleton, cell) {
-    const min = [Infinity, Infinity, Infinity];
-    const max = [-Infinity, -Infinity, -Infinity];
+function framework_bounds(skeleton) {
+    const box = Float64Array.of(Infinity, Infinity, Infinity, -Infinity, -Infinity, -Infinity);
     const p = new Float32Array(3);
     for (let v = 0; v < skeleton.node_count; v++) {
         skeleton.node_read_position(p, 0, v);
-        for (let i = 0; i < 3; i++) {
-            min[i] = Math.min(min[i], p[i]);
-            max[i] = Math.max(max[i], p[i]);
-        }
+        grow_box(box, p[0], p[1], p[2]);
+    }
+    return box;
+}
+
+/**
+ * Grows `box` round every carrier's units and every living axis.
+ * @param {Float64Array} box
+ * @param {ShootCarrier[]} carriers
+ * @param {Array<{alive: boolean, points: number[]}>} axes
+ */
+function crown_bounds(box, carriers, axes) {
+    for (const c of carriers) {
+        for (let i = 0; i < c.points.length; i += 3) grow_box(box, c.points[i], c.points[i + 1], c.points[i + 2]);
     }
+    for (const axis of axes) {
+        if (!axis.alive) continue;
+        const p = axis.points;
+        for (let i = 0; i < p.length; i += 3) grow_box(box, p[i], p[i + 1], p[i + 2]);
+    }
+}
+
+/**
+ * @param {Float64Array} box
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ */
+function grow_box(box, x, y, z) {
+    box[0] = Math.min(box[0], x);
+    box[1] = Math.min(box[1], y);
+    box[2] = Math.min(box[2], z);
+    box[3] = Math.max(box[3], x);
+    box[4] = Math.max(box[4], y);
+    box[5] = Math.max(box[5], z);
+}
+
+/**
+ * Whether `field` still reaches half of {@link LIGHT_FIELD_MARGIN} past `box` all round.
+ * @param {ShootLightField} field
+ * @param {Float64Array} box
+ * @returns {boolean}
+ */
+function field_holds(field, box) {
+    const half = LIGHT_FIELD_MARGIN * 0.5;
+    const n = [field.nx, field.ny, field.nz];
     for (let i = 0; i < 3; i++) {
-        min[i] -= LIGHT_FIELD_MARGIN;
-        max[i] += LIGHT_FIELD_MARGIN;
+        if (box[i] - half < field.min[i] || box[i + 3] + half > field.min[i] + n[i] * field.cell) return false;
     }
+    return true;
+}
+
+/**
+ * A light field over `box` and {@link LIGHT_FIELD_MARGIN} around it.
+ * @param {Float64Array} box
+ * @param {number} cell
+ * @returns {ShootLightField}
+ */
+function make_light_field(box, cell) {
+    const min = [box[0] - LIGHT_FIELD_MARGIN, box[1] - LIGHT_FIELD_MARGIN, box[2] - LIGHT_FIELD_MARGIN];
+    const max = [box[3] + LIGHT_FIELD_MARGIN, box[4] + LIGHT_FIELD_MARGIN, box[5] + LIGHT_FIELD_MARGIN];
     return new ShootLightField(min, max, cell);
 }
 
@@ -548,7 +1015,7 @@ function deposit_leaves(field, species, carriers, axes, season, leafy, leaf_area
  * @returns {number}
  */
 function shed_rank(p, order, length, age, rule, rng) {
-    return Math.log(Math.max(1e-6, p)) + 1.5 * age - 0.5 * order + Math.log(length / rule.mean_unit_length) + 0.5 * rng();
+    return Math.log(Math.max(1e-6, p)) + 1.5 * age - 0.5 * order + Math.log(length / shoot_order_value(rule.mean_unit_length, order)) + 0.5 * rng();
 }
 
 /**