@woosh/meep-engine 3.57.0 → 3.58.0

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

@@ -49,7 +49,7 @@ export class ShootFrameworkHash {
             skeleton.node_read_position(p0, 0, skeleton.segment_v0(e));
             skeleton.node_read_position(p1, 0, skeleton.segment_v1(e));
             const r = Math.max(skeleton.node_read_radius(skeleton.segment_v0(e)), skeleton.node_read_radius(skeleton.segment_v1(e))) + CLEARANCE;
-            this.#each_cell(p0, p1, r, -1, -1, -1, -1, -1, e);
+            this.#each_cell(p0, p1, r, -1, -1, -1, -1, -1, -1, e);
         }
     }
 
@@ -57,7 +57,7 @@ export class ShootFrameworkHash {
      * Visits every cell the box around segment `a`-`b` padded by `pad` covers: registers segment `register` in each,
      * or with `register < 0` tests each cell's segments against the capsule (see {@link hits}).
      */
-    #each_cell(a, b, pad, radius, exempt_branch, exempt_edge, ev0, ev1, register) {
+    #each_cell(a, b, pad, radius, exempt_branch, exempt_edge, ev0, ev1, exempt_family, register) {
         const x0 = Math.floor((Math.min(a[0], b[0]) - pad) / FRAMEWORK_CELL), x1 = Math.floor((Math.max(a[0], b[0]) + pad) / FRAMEWORK_CELL);
         const y0 = Math.floor((Math.min(a[1], b[1]) - pad) / FRAMEWORK_CELL), y1 = Math.floor((Math.max(a[1], b[1]) + pad) / FRAMEWORK_CELL);
         const z0 = Math.floor((Math.min(a[2], b[2]) - pad) / FRAMEWORK_CELL), z1 = Math.floor((Math.max(a[2], b[2]) + pad) / FRAMEWORK_CELL);
@@ -73,7 +73,7 @@ export class ShootFrameworkHash {
                 continue;
             }
             const list = this.cells.get(key);
-            if (list !== undefined && this.#test(list, a, b, radius, exempt_branch, exempt_edge, ev0, ev1)) {
+            if (list !== undefined && this.#test(list, a, b, radius, exempt_branch, exempt_edge, ev0, ev1, exempt_family)) {
                 return true;
             }
         }
@@ -83,7 +83,7 @@ export class ShootFrameworkHash {
     /**
      * Whether a cell's segments meet the capsule.
      */
-    #test(list, a, b, radius, exempt_branch, exempt_edge, ev0, ev1) {
+    #test(list, a, b, radius, exempt_branch, exempt_edge, ev0, ev1, exempt_family) {
         const skeleton = this.skeleton;
         const q0 = SCRATCH_Q0;
         const q1 = SCRATCH_Q1;
@@ -92,8 +92,10 @@ export class ShootFrameworkHash {
             if (this.seen[e] === this.query) continue;
             this.seen[e] = this.query;
             const v0 = skeleton.segment_v0(e), v1 = skeleton.segment_v1(e);
-            if (e === exempt_edge || (skeleton.node_branch_id(v1) === exempt_branch
+            const branch = skeleton.node_branch_id(v1);
+            if (e === exempt_edge || (branch === exempt_branch
                 && (v0 === ev0 || v0 === ev1 || v1 === ev0 || v1 === ev1))) continue;
+            if (exempt_family >= 0 && (branch === exempt_family || skeleton.branch_parent[branch] === exempt_family)) continue;
             skeleton.node_read_position(q0, 0, v0);
             skeleton.node_read_position(q1, 0, v1);
             line3_compute_segment_segment_closest_points(SCRATCH_ST, a[0], a[1], a[2], b[0], b[1], b[2], q0[0], q0[1], q0[2], q1[0], q1[1], q1[2]);
@@ -110,20 +112,23 @@ export class ShootFrameworkHash {
 
     /**
      * Whether the capsule from `a` to `b` of radius `radius` runs into a framework segment, other than those of
-     * `exempt_branch` within one segment of `exempt_edge` (the junction it grows from). Radii are the skeleton's now.
+     * `exempt_branch` within one segment of `exempt_edge` (the junction it grows from), and those of `exempt_family`
+     * and the framework branches it carries: a branch's own extension grows on from its tip and joins what grows on
+     * it. Radii are the skeleton's now.
      *
      * @param {ArrayLike<number>} a
      * @param {ArrayLike<number>} b
      * @param {number} radius
      * @param {number} exempt_branch
      * @param {number} exempt_edge
+     * @param {number} [exempt_family] -1 for none
      * @returns {boolean}
      */
-    hits(a, b, radius, exempt_branch, exempt_edge) {
+    hits(a, b, radius, exempt_branch, exempt_edge, exempt_family = -1) {
         const skeleton = this.skeleton;
         const ev0 = exempt_edge >= 0 ? skeleton.segment_v0(exempt_edge) : -1;
         const ev1 = exempt_edge >= 0 ? skeleton.segment_v1(exempt_edge) : -1;
         this.query++;
-        return this.#each_cell(a, b, radius, radius, exempt_branch, exempt_edge, ev0, ev1, -1);
+        return this.#each_cell(a, b, radius, radius, exempt_branch, exempt_edge, ev0, ev1, exempt_family, -1);
     }
 }

package/src/generation/foliage/skeleton/ShootGirth.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ShootGirth.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/skeleton/ShootGirth.js"],"names":[],"mappings":"AA2LA;;;;;;;;;GASG;AACH,8CANW,OAAO,mBAAmB,EAAE,YAAY,KACxC,MAAM,KACN,MAAM,QACN,MAAM,GACJ,OAAO,CAgBnB;AA1MD;;;;;;;;;;;GAWG;AACH;IACI;;;;;OAKG;IACH,sBALW,OAAO,mBAAmB,EAAE,YAAY,YACxC,OAAO,6BAA6B,EAAE,YAAY,EAAE,mBACpD,MAAM,SACN,MAAM,EAiBhB;IAdG,mDAAwB;IACxB,+DAAwB;IACxB,cAAkB;IAKlB,0BAA4B;IAC5B,aAAe;IACf,aAAe;IAOnB;;;;;;OAMG;IACH,aAHW,MAAM,OAAO,6BAA6B,EAAE,SAAS,GAAG;QAAC,KAAK,EAAE,OAAO,CAAC;QAAC,KAAK,EAAE,MAAM,EAAE,CAAA;KAAC,CAAC,UAC1F,MAAM,QAQhB;;CA+HJ"}
+{"version":3,"file":"ShootGirth.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/skeleton/ShootGirth.js"],"names":[],"mappings":"AA4LA;;;;;;;;;GASG;AACH,8CANW,OAAO,mBAAmB,EAAE,YAAY,KACxC,MAAM,KACN,MAAM,QACN,MAAM,GACJ,OAAO,CAgBnB;AA3MD;;;;;;;;;;;GAWG;AACH;IACI;;;;;OAKG;IACH,sBALW,OAAO,mBAAmB,EAAE,YAAY,YACxC,OAAO,6BAA6B,EAAE,YAAY,EAAE,mBACpD,MAAM,SACN,MAAM,EAiBhB;IAdG,mDAAwB;IACxB,+DAAwB;IACxB,cAAkB;IAKlB,0BAA4B;IAC5B,aAAe;IACf,aAAe;IAOnB;;;;;;OAMG;IACH,aAHW,MAAM,OAAO,6BAA6B,EAAE,SAAS,GAAG;QAAC,KAAK,EAAE,OAAO,CAAC;QAAC,KAAK,EAAE,MAAM,EAAE,CAAA;KAAC,CAAC,UAC1F,MAAM,QAQhB;;CAgIJ"}

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

@@ -71,14 +71,14 @@ export class ShootGirth {
         const pipe = new Array(axes.length);
         const demand_of = new Array(axes.length);
         for (let m = 0; m < axes.length; m++) {
-            if (!axes[m].alive) continue;
+            if (!axes[m].alive || axes[m].units.length === 0) continue;
             const n = axes[m].units.length;
             pipe[m] = new Float64Array(n + 1);
             demand_of[m] = new Float64Array(n);
         }
         for (let m = axes.length - 1; m >= 0; m--) {
             const axis = axes[m];
-            if (!axis.alive) continue;
+            if (!axis.alive || axis.units.length === 0) continue;
             const units = axis.units;
             const n = units.length;
             const area = pipe[m];
@@ -102,9 +102,10 @@ export class ShootGirth {
                 pipe[axis.parent][axis.parent_unit] += area[0];
                 demand_of[axis.parent][axis.parent_unit] = Math.max(demand_of[axis.parent][axis.parent_unit], r[0] / SHOOT_LATERAL_RADIUS_RATIO);
             } else {
+                // a carrier's own extension goes on at its girth; a lateral is held at the ratio
                 const c = this.carriers[axis.system];
                 c.carrier_area[axis.parent_unit] += area[0];
-                c.carrier_demand[axis.parent_unit] = Math.max(c.carrier_demand[axis.parent_unit], r[0] / SHOOT_LATERAL_RADIUS_RATIO);
+                c.carrier_demand[axis.parent_unit] = Math.max(c.carrier_demand[axis.parent_unit], r[0] / (axis.extends ? 1 : SHOOT_LATERAL_RADIUS_RATIO));
             }
         }
     }
@@ -146,9 +147,9 @@ export class ShootGirth {
         // the radius a lateral sees where it joins is between two nodes: hold it there too
         for (let m = 0; m < axes.length; m++) {
             const axis = axes[m];
-            if (!axis.alive || axis.system !== s || axis.parent >= 0) continue;
+            if (!axis.alive || axis.system !== s || axis.parent >= 0 || axis.units.length === 0) continue;
             const located = shoot_locate_on_chain(skeleton, c.nodes, c.edges, (c.starts[axis.parent_unit] + axis.u * units[axis.parent_unit]) / c.length);
-            shoot_hold_junction(skeleton, located.edge, located.u, axis.radii[0] / SHOOT_LATERAL_RADIUS_RATIO);
+            shoot_hold_junction(skeleton, located.edge, located.u, axis.radii[0] / (axis.extends ? 1 : SHOOT_LATERAL_RADIUS_RATIO));
         }
         // and the carrier still tapers towards its tip
         for (let i = chain.length - 2; i >= 0; i--) {

package/src/generation/foliage/skeleton/ShootLightField.d.ts

@@ -61,6 +61,15 @@ export class ShootLightField {
      * @param {number} clumping
      */
     solve(clumping: number): void;
+    /**
+     * The direction light grows brighter in at a point: the irradiance's central difference over a cell along each
+     * axis, normalised; zero where it is even, as under open sky.
+     * @param {Float32Array|Float64Array|number[]} out
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     */
+    gradient_at(out: Float32Array | Float64Array | number[], x: number, y: number, z: number): void;
     /**
      * Relative irradiance at a point, 1 outside the grid.
      * @param {number} x

package/src/generation/foliage/skeleton/ShootLightField.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ShootLightField.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/skeleton/ShootLightField.js"],"names":[],"mappings":"AA+DA;;;;;;GAMG;AACH;IACI;;;;OAIG;IACH,iBAJW,UAAU,MAAM,CAAC,OACjB,UAAU,MAAM,CAAC,QACjB,MAAM,EAqBhB;IAjBG,aAAgB;IAChB,kBAAiC;IACjC,WAA0D;IAC1D,WAA0D;IAC1D,WAA0D;IAE1D;;;OAGG;IACH,WAFU,YAAY,CAEc;IACpC;;;OAGG;IACH,YAFU,YAAY,CAEuB;IAC7C,4BAAwC;IAG5C;;OAEG;IACH,cAEC;IAED;;;;;;OAMG;IACH,SALW,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAQlB;IAED;;;;;;OAMG;IACH,WALW,MAAM,KACN,MAAM,KACN,MAAM,QACN,MAAM,QAKhB;IAED;;;;;OAKG;IACH,mBAJW,UAAU,MAAM,CAAC,KACjB,UAAU,MAAM,CAAC,QACjB,MAAM,QAUhB;IAED;;;;OAIG;IACH,gBAFW,MAAM,QAiChB;IAED;;;;;;OAMG;IACH,iBALW,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAKlB;CACJ"}
+{"version":3,"file":"ShootLightField.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/skeleton/ShootLightField.js"],"names":[],"mappings":"AA+DA;;;;;;GAMG;AACH;IACI;;;;OAIG;IACH,iBAJW,UAAU,MAAM,CAAC,OACjB,UAAU,MAAM,CAAC,QACjB,MAAM,EAqBhB;IAjBG,aAAgB;IAChB,kBAAiC;IACjC,WAA0D;IAC1D,WAA0D;IAC1D,WAA0D;IAE1D;;;OAGG;IACH,WAFU,YAAY,CAEc;IACpC;;;OAGG;IACH,YAFU,YAAY,CAEuB;IAC7C,4BAAwC;IAG5C;;OAEG;IACH,cAEC;IAED;;;;;;OAMG;IACH,SALW,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAQlB;IAED;;;;;;OAMG;IACH,WALW,MAAM,KACN,MAAM,KACN,MAAM,QACN,MAAM,QAKhB;IAED;;;;;OAKG;IACH,mBAJW,UAAU,MAAM,CAAC,KACjB,UAAU,MAAM,CAAC,QACjB,MAAM,QAUhB;IAED;;;;OAIG;IACH,gBAFW,MAAM,QAiChB;IAED;;;;;;;OAOG;IACH,iBALW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,KAClC,MAAM,KACN,MAAM,KACN,MAAM,QAiBhB;IAED;;;;;;OAMG;IACH,iBALW,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAKlB;CACJ"}

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

@@ -183,6 +183,31 @@ export class ShootLightField {
         }
     }
 
+    /**
+     * The direction light grows brighter in at a point: the irradiance's central difference over a cell along each
+     * axis, normalised; zero where it is even, as under open sky.
+     * @param {Float32Array|Float64Array|number[]} out
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     */
+    gradient_at(out, x, y, z) {
+        const c = this.cell;
+        const gx = this.irradiance_at(x + c, y, z) - this.irradiance_at(x - c, y, z);
+        const gy = this.irradiance_at(x, y + c, z) - this.irradiance_at(x, y - c, z);
+        const gz = this.irradiance_at(x, y, z + c) - this.irradiance_at(x, y, z - c);
+        const len = Math.hypot(gx, gy, gz);
+        if (len > 1e-9) {
+            out[0] = gx / len;
+            out[1] = gy / len;
+            out[2] = gz / len;
+        } else {
+            out[0] = 0;
+            out[1] = 0;
+            out[2] = 0;
+        }
+    }
+
     /**
      * Relative irradiance at a point, 1 outside the grid.
      * @param {number} x

package/src/generation/foliage/skeleton/ShootWoodHash.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Spatial hash of the annual units the shoot axes have grown, so a shoot can be kept from growing into older shoot
+ * wood, and thinner wood that thicker wood has grown into can be found. A unit is added once, when it has grown, under
+ * the cells its axis line crosses; a query reads every unit's place and radius from its axis as they are then, and
+ * reaches as far round as the thickest wood ({@link max_radius}), so wood that thickens needs no re-adding. The units
+ * of an axis that has died are passed over.
+ */
+export class ShootWoodHash {
+    /**
+     * Radius (m) of unit `k` of `axis` at `t` along it: its radii once its wood has thickened, a new shoot's before.
+     * @param {{radii: number[], units: number[]}} axis
+     * @param {number} k
+     * @param {number} t
+     * @returns {number}
+     */
+    static radius_at(axis: {
+        radii: number[];
+        units: number[];
+    }, k: number, t: number): number;
+    /**
+     * @param {Array<{alive: boolean, points: number[], radii: number[], units: number[]}>} axes
+     */
+    constructor(axes: Array<{
+        alive: boolean;
+        points: number[];
+        radii: number[];
+        units: number[];
+    }>);
+    /** @type {Map<number, number[]>} */
+    cells: Map<number, number[]>;
+    /**
+     * Thickest living unit (m) in each cell as of the last {@link refresh}, a unit added since counting as infinitely
+     * thick, so a query that wants only wood at least so thick can pass a cell by.
+     * @type {Map<number, number>}
+     */
+    cell_max: Map<number, number>;
+    /**
+     * Thickest radius (m) of any unit, so a query reaches every unit whose wood may meet it.
+     * @type {number}
+     */
+    max_radius: number;
+    /**
+     * Axis of each added unit.
+     * @type {number[]}
+     */
+    unit_axis: number[];
+    /**
+     * Index of each added unit along its axis.
+     * @type {number[]}
+     */
+    unit_index: number[];
+    /**
+     * Stamp of the last query that met each unit, so each is tested once a query.
+     * @type {number[]}
+     */
+    seen: number[];
+    query: number;
+    axes: {
+        alive: boolean;
+        points: number[];
+        radii: number[];
+        units: number[];
+    }[];
+    /**
+     * Adds unit `k` of axis `m`, grown.
+     * @param {number} m
+     * @param {number} k
+     */
+    add(m: number, k: number): void;
+    /**
+     * Records each cell's thickest living unit, after the wood has thickened, and the thickest of all
+     * ({@link max_radius}).
+     */
+    refresh(): void;
+    /**
+     * The axis of the first living unit whose wood meets the capsule from `a` to `b` of radius `radius`, other than
+     * units nowhere as thick as `min_radius` and those `skip(axis, unit, wood_radius, s)` passes over, `wood_radius`
+     * being the unit's radius where they meet and `s` how far along the capsule, 0 at `a`; -1 for none.
+     *
+     * @param {ArrayLike<number>} a
+     * @param {ArrayLike<number>} b
+     * @param {number} radius
+     * @param {number} min_radius
+     * @param {function(number, number, number, number): boolean} skip
+     * @returns {number}
+     */
+    hits(a: ArrayLike<number>, b: ArrayLike<number>, radius: number, min_radius: number, skip: (arg0: number, arg1: number, arg2: number, arg3: number) => boolean): number;
+}
+//# sourceMappingURL=ShootWoodHash.d.ts.map

package/src/generation/foliage/skeleton/ShootWoodHash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ShootWoodHash.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/skeleton/ShootWoodHash.js"],"names":[],"mappings":"AAwBA;;;;;;GAMG;AACH;IA8FI;;;;;;OAMG;IACH,uBALW;QAAC,KAAK,EAAE,MAAM,EAAE,CAAC;QAAC,KAAK,EAAE,MAAM,EAAE,CAAA;KAAC,KAClC,MAAM,KACN,MAAM,GACJ,MAAM,CAMlB;IApED;;OAEG;IACH,kBAFW,MAAM;QAAC,KAAK,EAAE,OAAO,CAAC;QAAC,MAAM,EAAE,MAAM,EAAE,CAAC;QAAC,KAAK,EAAE,MAAM,EAAE,CAAC;QAAC,KAAK,EAAE,MAAM,EAAE,CAAA;KAAC,CAAC,EAIrF;IAzCD,oCAAoC;IACpC,OADW,IAAI,MAAM,EAAE,MAAM,EAAE,CAAC,CACd;IAElB;;;;OAIG;IACH,UAFU,IAAI,MAAM,EAAE,MAAM,CAAC,CAER;IAErB;;;OAGG;IACH,YAFU,MAAM,CAED;IAEf;;;OAGG;IACH,WAFU,MAAM,EAAE,CAEH;IAEf;;;OAGG;IACH,YAFU,MAAM,EAAE,CAEF;IAEhB;;;OAGG;IACH,MAFU,MAAM,EAAE,CAER;IAEV,cAAU;IAMN;eAHqB,OAAO;gBAAU,MAAM,EAAE;eAAS,MAAM,EAAE;eAAS,MAAM,EAAE;QAGhE;IAGpB;;;;OAIG;IACH,OAHW,MAAM,KACN,MAAM,QAsBhB;IAED;;;OAGG;IACH,gBAiBC;IAeD;;;;;;;;;;;OAWG;IACH,QAPW,UAAU,MAAM,CAAC,KACjB,UAAU,MAAM,CAAC,UACjB,MAAM,cACN,MAAM,eACG,MAAM,QAAE,MAAM,QAAE,MAAM,QAAE,MAAM,KAAG,OAAO,GAC/C,MAAM,CA6ClB;CACJ"}

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

@@ -0,0 +1,195 @@
+import { line3_compute_segment_segment_closest_points } from "../../../core/geom/3d/line/line3_compute_segment_segment_closest_points.js";
+import { shoot_radius } from "./shoot_geometry.js";
+
+/**
+ * Edge (m) of a cell of the hash: about a twig's annual unit (5-11 cm in the presets' higher orders), which most of the
+ * units are, so a cell holds few. Measured against 0.25 and 0.05 m on the pine and the spruce.
+ * @type {number}
+ */
+const WOOD_CELL = 0.1;
+
+/**
+ * Gap (m) a shoot keeps from other wood, as from the framework's (`ShootFrameworkHash`).
+ * @type {number}
+ */
+const CLEARANCE = 0.001;
+
+/**
+ * Cells per axis the integer key spans, centred on the origin: 2048 cells of 0.1 m is 205 m.
+ * @type {number}
+ */
+const KEY_SPAN = 2048;
+
+const SCRATCH_ST = new Float64Array(2);
+
+/**
+ * Spatial hash of the annual units the shoot axes have grown, so a shoot can be kept from growing into older shoot
+ * wood, and thinner wood that thicker wood has grown into can be found. A unit is added once, when it has grown, under
+ * the cells its axis line crosses; a query reads every unit's place and radius from its axis as they are then, and
+ * reaches as far round as the thickest wood ({@link max_radius}), so wood that thickens needs no re-adding. The units
+ * of an axis that has died are passed over.
+ */
+export class ShootWoodHash {
+    /** @type {Map<number, number[]>} */
+    cells = new Map();
+
+    /**
+     * Thickest living unit (m) in each cell as of the last {@link refresh}, a unit added since counting as infinitely
+     * thick, so a query that wants only wood at least so thick can pass a cell by.
+     * @type {Map<number, number>}
+     */
+    cell_max = new Map();
+
+    /**
+     * Thickest radius (m) of any unit, so a query reaches every unit whose wood may meet it.
+     * @type {number}
+     */
+    max_radius = 0;
+
+    /**
+     * Axis of each added unit.
+     * @type {number[]}
+     */
+    unit_axis = [];
+
+    /**
+     * Index of each added unit along its axis.
+     * @type {number[]}
+     */
+    unit_index = [];
+
+    /**
+     * Stamp of the last query that met each unit, so each is tested once a query.
+     * @type {number[]}
+     */
+    seen = [];
+
+    query = 0;
+
+    /**
+     * @param {Array<{alive: boolean, points: number[], radii: number[], units: number[]}>} axes
+     */
+    constructor(axes) {
+        this.axes = axes;
+    }
+
+    /**
+     * Adds unit `k` of axis `m`, grown.
+     * @param {number} m
+     * @param {number} k
+     */
+    add(m, k) {
+        const id = this.unit_axis.length;
+        this.unit_axis.push(m);
+        this.unit_index.push(k);
+        this.seen.push(0);
+        const p = this.axes[m].points;
+        const a = k * 3, b = a + 3;
+        const x0 = Math.floor(Math.min(p[a], p[b]) / WOOD_CELL), x1 = Math.floor(Math.max(p[a], p[b]) / WOOD_CELL);
+        const y0 = Math.floor(Math.min(p[a + 1], p[b + 1]) / WOOD_CELL), y1 = Math.floor(Math.max(p[a + 1], p[b + 1]) / WOOD_CELL);
+        const z0 = Math.floor(Math.min(p[a + 2], p[b + 2]) / WOOD_CELL), z1 = Math.floor(Math.max(p[a + 2], p[b + 2]) / WOOD_CELL);
+        for (let x = x0; x <= x1; x++) for (let y = y0; y <= y1; y++) for (let z = z0; z <= z1; z++) {
+            const key = ((x + KEY_SPAN / 2) * KEY_SPAN + (y + KEY_SPAN / 2)) * KEY_SPAN + (z + KEY_SPAN / 2);
+            let list = this.cells.get(key);
+            if (list === undefined) {
+                list = [];
+                this.cells.set(key, list);
+            }
+            list.push(id);
+            this.cell_max.set(key, Infinity);
+        }
+    }
+
+    /**
+     * Records each cell's thickest living unit, after the wood has thickened, and the thickest of all
+     * ({@link max_radius}).
+     */
+    refresh() {
+        const axes = this.axes;
+        let most = 0;
+        for (const [key, list] of this.cells) {
+            let max = 0;
+            for (let i = 0; i < list.length; i++) {
+                const id = list[i];
+                const axis = axes[this.unit_axis[id]];
+                if (!axis.alive) continue;
+                const k = this.unit_index[id];
+                const thickest = axis.radii.length > k + 1 ? Math.max(axis.radii[k], axis.radii[k + 1]) : shoot_radius(axis.units[k], 0);
+                if (thickest > max) max = thickest;
+            }
+            this.cell_max.set(key, max);
+            if (max > most) most = max;
+        }
+        this.max_radius = most;
+    }
+
+    /**
+     * Radius (m) of unit `k` of `axis` at `t` along it: its radii once its wood has thickened, a new shoot's before.
+     * @param {{radii: number[], units: number[]}} axis
+     * @param {number} k
+     * @param {number} t
+     * @returns {number}
+     */
+    static radius_at(axis, k, t) {
+        const r = axis.radii;
+        if (r.length <= k + 1) return shoot_radius(axis.units[k], 0);
+        return r[k] + (r[k + 1] - r[k]) * t;
+    }
+
+    /**
+     * The axis of the first living unit whose wood meets the capsule from `a` to `b` of radius `radius`, other than
+     * units nowhere as thick as `min_radius` and those `skip(axis, unit, wood_radius, s)` passes over, `wood_radius`
+     * being the unit's radius where they meet and `s` how far along the capsule, 0 at `a`; -1 for none.
+     *
+     * @param {ArrayLike<number>} a
+     * @param {ArrayLike<number>} b
+     * @param {number} radius
+     * @param {number} min_radius
+     * @param {function(number, number, number, number): boolean} skip
+     * @returns {number}
+     */
+    hits(a, b, radius, min_radius, skip) {
+        const pad = radius + this.max_radius + CLEARANCE;
+        const x0 = Math.floor((Math.min(a[0], b[0]) - pad) / WOOD_CELL), x1 = Math.floor((Math.max(a[0], b[0]) + pad) / WOOD_CELL);
+        const y0 = Math.floor((Math.min(a[1], b[1]) - pad) / WOOD_CELL), y1 = Math.floor((Math.max(a[1], b[1]) + pad) / WOOD_CELL);
+        const z0 = Math.floor((Math.min(a[2], b[2]) - pad) / WOOD_CELL), z1 = Math.floor((Math.max(a[2], b[2]) + pad) / WOOD_CELL);
+        const query = ++this.query;
+        const axes = this.axes;
+        const ax0 = Math.min(a[0], b[0]) - radius, ax1 = Math.max(a[0], b[0]) + radius;
+        const ay0 = Math.min(a[1], b[1]) - radius, ay1 = Math.max(a[1], b[1]) + radius;
+        const az0 = Math.min(a[2], b[2]) - radius, az1 = Math.max(a[2], b[2]) + radius;
+        for (let x = x0; x <= x1; x++) for (let y = y0; y <= y1; y++) for (let z = z0; z <= z1; z++) {
+            const key = ((x + KEY_SPAN / 2) * KEY_SPAN + (y + KEY_SPAN / 2)) * KEY_SPAN + (z + KEY_SPAN / 2);
+            const list = this.cells.get(key);
+            if (list === undefined || this.cell_max.get(key) < min_radius) continue;
+            for (let i = 0; i < list.length; i++) {
+                const id = list[i];
+                if (this.seen[id] === query) continue;
+                this.seen[id] = query;
+                const m = this.unit_axis[id];
+                const axis = axes[m];
+                if (!axis.alive) continue;
+                const k = this.unit_index[id];
+                const p = axis.points;
+                const q = k * 3;
+                // the thickest the unit is, and whether its box padded by that meets the capsule's
+                const thickest = axis.radii.length > k + 1 ? Math.max(axis.radii[k], axis.radii[k + 1]) : shoot_radius(axis.units[k], 0);
+                if (thickest < min_radius) continue;
+                const pad_k = thickest + CLEARANCE;
+                if (Math.min(p[q], p[q + 3]) - pad_k > ax1 || Math.max(p[q], p[q + 3]) + pad_k < ax0
+                    || Math.min(p[q + 1], p[q + 4]) - pad_k > ay1 || Math.max(p[q + 1], p[q + 4]) + pad_k < ay0
+                    || Math.min(p[q + 2], p[q + 5]) - pad_k > az1 || Math.max(p[q + 2], p[q + 5]) + pad_k < az0) continue;
+                line3_compute_segment_segment_closest_points(SCRATCH_ST, a[0], a[1], a[2], b[0], b[1], b[2], p[q], p[q + 1], p[q + 2], p[q + 3], p[q + 4], p[q + 5]);
+                const s = SCRATCH_ST[0], t = SCRATCH_ST[1];
+                const r = ShootWoodHash.radius_at(axis, k, t);
+                const dx = a[0] + (b[0] - a[0]) * s - (p[q] + (p[q + 3] - p[q]) * t);
+                const dy = a[1] + (b[1] - a[1]) * s - (p[q + 1] + (p[q + 4] - p[q + 1]) * t);
+                const dz = a[2] + (b[2] - a[2]) * s - (p[q + 2] + (p[q + 5] - p[q + 2]) * t);
+                if (Math.hypot(dx, dy, dz) >= r + radius + CLEARANCE) continue;
+                if (skip(m, k, r, s)) continue;
+                return m;
+            }
+        }
+        return -1;
+    }
+}

package/src/generation/foliage/skeleton/TreeSkeleton.d.ts

@@ -410,6 +410,12 @@ export class TreeSkeleton {
      * @returns {number}
      */
     node_t_norm(v: number): number;
+    /**
+     * Sets node `v`'s normalized position along its branch, as when the branch grows longer.
+     * @param {number} v
+     * @param {number} t_norm
+     */
+    node_write_t_norm(v: number, t_norm: number): void;
     /**
      * @param {number} v
      * @returns {number}

package/src/generation/foliage/skeleton/TreeSkeleton.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TreeSkeleton.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/skeleton/TreeSkeleton.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"TreeSkeleton.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/skeleton/TreeSkeleton.js"],"names":[],"mappings":"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"}

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

@@ -898,6 +898,15 @@ export class TreeSkeleton {
         return /** @type {Float32Array} */ (this.attr_node_spine_param.data)[v * 3];
     }
 
+    /**
+     * Sets node `v`'s normalized position along its branch, as when the branch grows longer.
+     * @param {number} v
+     * @param {number} t_norm
+     */
+    node_write_t_norm(v, t_norm) {
+        /** @type {Float32Array} */ (this.attr_node_spine_param.data)[v * 3] = t_norm;
+    }
+
     /**
      * @param {number} v
      * @returns {number}

package/src/generation/foliage/skeleton/shoot_demography.d.ts

@@ -11,12 +11,25 @@
  */
 export function shoot_sample_unit_length(rng: () => number, mean: number, order: number, rule: import("../config/ShootSystemRule.js").ShootSystemRule): number;
 /**
- * Expected new long shoots a living shoot of the carrier's order yields in a year: its terminal, plus the laterals its
- * bud zones grow out on a unit of `rule.mean_unit_length`. About 2.65 for oak [BB2000 p. 11]. Short shoots are not
- * counted: they bear no laterals.
+ * A new shoot's chance of surviving its first season in relative light `light`: the net shoots a shoot leaves there,
+ * over the `gross` new shoots its mother's buds grow (`shoot_expected_yield`). In full light it is 1, every shoot the
+ * buds grow kept; shade sheds them, down to 1 shoot in `gross` at the compensation light and fewer below it.
+ *
+ * @param {import("../config/ShootGrowthConfig.js").ShootGrowthConfig} growth
+ * @param {number} light relative irradiance, 1 under open sky
+ * @param {number} gross
+ * @returns {number}
+ */
+export function shoot_survival(growth: import("../config/ShootGrowthConfig.js").ShootGrowthConfig, light: number, gross: number): number;
+/**
+ * Expected new long shoots a living shoot of `order` yields in a year from a unit `length` metres long: its terminal,
+ * plus the laterals its bud zones grow out. About 2.65 for oak on a unit of its mean length [BB2000 p. 11]. Short shoots
+ * are not counted: they bear no laterals.
  *
  * @param {import("../config/ShootSystemRule.js").ShootSystemRule} rule
+ * @param {number} order 1-based, in the rule's numbering
+ * @param {number} length metres
  * @returns {number}
  */
-export function shoot_expected_yield(rule: import("../config/ShootSystemRule.js").ShootSystemRule): number;
+export function shoot_expected_yield(rule: import("../config/ShootSystemRule.js").ShootSystemRule, order: number, length: number): number;
 //# sourceMappingURL=shoot_demography.d.ts.map

package/src/generation/foliage/skeleton/shoot_demography.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shoot_demography.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/skeleton/shoot_demography.js"],"names":[],"mappings":"AAoDA;;;;;;;;;;GAUG;AACH,oDANsB,MAAM,QACjB,MAAM,SACN,MAAM,QACN,OAAO,8BAA8B,EAAE,eAAe,GACpD,MAAM,CAgBlB;AAED;;;;;;;GAOG;AACH,2CAHW,OAAO,8BAA8B,EAAE,eAAe,GACpD,MAAM,CAUlB"}
+{"version":3,"file":"shoot_demography.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/skeleton/shoot_demography.js"],"names":[],"mappings":"AAoDA;;;;;;;;;;GAUG;AACH,oDANsB,MAAM,QACjB,MAAM,SACN,MAAM,QACN,OAAO,8BAA8B,EAAE,eAAe,GACpD,MAAM,CAgBlB;AAED;;;;;;;;;GASG;AACH,uCALW,OAAO,gCAAgC,EAAE,iBAAiB,SAC1D,MAAM,SACN,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;;;;;GASG;AACH,2CALW,OAAO,8BAA8B,EAAE,eAAe,SACtD,MAAM,UACN,MAAM,GACJ,MAAM,CAUlB"}

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

@@ -78,19 +78,35 @@ export function shoot_sample_unit_length(rng, mean, order, rule) {
 }
 
 /**
- * Expected new long shoots a living shoot of the carrier's order yields in a year: its terminal, plus the laterals its
- * bud zones grow out on a unit of `rule.mean_unit_length`. About 2.65 for oak [BB2000 p. 11]. Short shoots are not
- * counted: they bear no laterals.
+ * A new shoot's chance of surviving its first season in relative light `light`: the net shoots a shoot leaves there,
+ * over the `gross` new shoots its mother's buds grow (`shoot_expected_yield`). In full light it is 1, every shoot the
+ * buds grow kept; shade sheds them, down to 1 shoot in `gross` at the compensation light and fewer below it.
+ *
+ * @param {import("../config/ShootGrowthConfig.js").ShootGrowthConfig} growth
+ * @param {number} light relative irradiance, 1 under open sky
+ * @param {number} gross
+ * @returns {number}
+ */
+export function shoot_survival(growth, light, gross) {
+    return clamp(growth.net_yield(light, gross) / gross, 0, 1);
+}
+
+/**
+ * Expected new long shoots a living shoot of `order` yields in a year from a unit `length` metres long: its terminal,
+ * plus the laterals its bud zones grow out. About 2.65 for oak on a unit of its mean length [BB2000 p. 11]. Short shoots
+ * are not counted: they bear no laterals.
  *
  * @param {import("../config/ShootSystemRule.js").ShootSystemRule} rule
+ * @param {number} order 1-based, in the rule's numbering
+ * @param {number} length metres
  * @returns {number}
  */
-export function shoot_expected_yield(rule) {
-    const order = rule.carrier_order;
+export function shoot_expected_yield(rule, order, length) {
     let y = 1;
+    if (order + 1 > rule.max_order) return y;
     for (let z = 0; z < rule.zones.length; z++) {
         const zone = rule.zones[z];
-        y += zone.bud_count(rule.mean_unit_length, order) * (shoot_order_value(zone.long, order) + shoot_order_value(zone.sylleptic, order));
+        y += zone.bud_count(length, order) * (shoot_order_value(zone.long, order) + shoot_order_value(zone.sylleptic, order));
     }
     return y;
 }

package/src/generation/foliage/skeleton/shoot_geometry.d.ts

@@ -33,14 +33,13 @@ export function shoot_normalize3(out: Float32Array | Float64Array | number[], x:
  */
 export function shoot_perpendicular3(out: Float32Array | Float64Array | number[], x: number, y: number, z: number): void;
 /**
- * Direction out of the crown and up at a point, as the foliage's phototropism reads it.
- * @param {Float32Array|Float64Array|number[]} out
+ * Whether framework branch `b`'s tip lies inside its parent's wood, on the parent's segment it grows from or the one
+ * either side: the parent has thickened over it.
  * @param {import("./TreeSkeleton.js").TreeSkeleton} skeleton
- * @param {number} x
- * @param {number} y
- * @param {number} z
+ * @param {number} b
+ * @returns {boolean}
  */
-export function shoot_outward3(out: Float32Array | Float64Array | number[], skeleton: import("./TreeSkeleton.js").TreeSkeleton, x: number, y: number, z: number): void;
+export function shoot_framework_buried(skeleton: import("./TreeSkeleton.js").TreeSkeleton, b: number): boolean;
 /**
  * The segment of a branch chain containing `t`, and where on it.
  * @param {import("./TreeSkeleton.js").TreeSkeleton} skeleton

package/src/generation/foliage/skeleton/shoot_geometry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shoot_geometry.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/skeleton/shoot_geometry.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,qCAJW,MAAM,OACN,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;;GAMG;AACH,0CAJW,MAAM,OACN,MAAM,GACJ,MAAM,CAIlB;AAcD;;;;;;GAMG;AACH,sCALW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,KAClC,MAAM,KACN,MAAM,KACN,MAAM,QAahB;AAED;;;;;;GAMG;AACH,0CALW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,KAClC,MAAM,KACN,MAAM,KACN,MAAM,QAShB;AAED;;;;;;;GAOG;AACH,oCANW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,YAClC,OAAO,mBAAmB,EAAE,YAAY,KACxC,MAAM,KACN,MAAM,KACN,MAAM,QAShB;AAED;;;;;;;GAOG;AACH,gDANW,OAAO,mBAAmB,EAAE,YAAY,SACxC,MAAM,EAAE,SACR,MAAM,EAAE,KACR,MAAM,GACJ;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAC,CAWrC;AAlFD;;;GAGG;AACH,+BAFU,MAAM,CAEuB;AAEvC;;;GAGG;AACH,yCAFU,MAAM,CAE+B"}
+{"version":3,"file":"shoot_geometry.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/skeleton/shoot_geometry.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,qCAJW,MAAM,OACN,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;;GAMG;AACH,0CAJW,MAAM,OACN,MAAM,GACJ,MAAM,CAIlB;AAcD;;;;;;GAMG;AACH,sCALW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,KAClC,MAAM,KACN,MAAM,KACN,MAAM,QAahB;AAED;;;;;;GAMG;AACH,0CALW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,KAClC,MAAM,KACN,MAAM,KACN,MAAM,QAShB;AAQD;;;;;;GAMG;AACH,iDAJW,OAAO,mBAAmB,EAAE,YAAY,KACxC,MAAM,GACJ,OAAO,CAqBnB;AAED;;;;;;;GAOG;AACH,gDANW,OAAO,mBAAmB,EAAE,YAAY,SACxC,MAAM,EAAE,SACR,MAAM,EAAE,KACR,MAAM,GACJ;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAC,CAWrC;AAnGD;;;GAGG;AACH,+BAFU,MAAM,CAEuB;AAEvC;;;GAGG;AACH,yCAFU,MAAM,CAE+B"}