@woosh/meep-engine 3.55.0 → 3.57.0

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

@@ -0,0 +1,109 @@
+import { clamp } from "../../../core/math/clamp.js";
+
+/**
+ * Radius (m) at the base of an annual unit `length` (m) long that grew `age` years ago: diameter `d = 0.27 + 0.02 l`
+ * (cm) for a current shoot and `0.40 + 0.02 l` a year on [BB2000 Table 7, all oaks], so a ring of 0.13 cm a year,
+ * carried on to older wood. Kept above the 1.9 mm the bark mesher draws without thin-strand artifacts. [BB2000]:
+ * Buck-Sorlin & Bell (2000), Forestry 73(1): 1-19.
+ * @param {number} length
+ * @param {number} age
+ * @returns {number}
+ */
+export function shoot_radius(length, age) {
+    return Math.max(SHOOT_MIN_RADIUS, shoot_wood_radius(length, age));
+}
+
+/**
+ * The radius of {@link shoot_radius} as the wood has it, before the floor the bark mesher draws at: what a shoot adds to
+ * the pipe model of the wood that carries it.
+ * @param {number} length
+ * @param {number} age
+ * @returns {number}
+ */
+export function shoot_wood_radius(length, age) {
+    return 0.5 * (0.27 + 0.13 * age + 0.02 * length * 100) / 100;
+}
+
+/**
+ * Thinnest radius (m) a shoot is drawn at.
+ * @type {number}
+ */
+export const SHOOT_MIN_RADIUS = 0.0019;
+
+/**
+ * Largest radius of a lateral relative to its mother where it grows out, as `tree_skeleton_compute_pipe_radii` holds it.
+ * @type {number}
+ */
+export const SHOOT_LATERAL_RADIUS_RATIO = 0.82;
+
+/**
+ * Normalises `(x, y, z)` into `out`; a zero vector becomes up.
+ * @param {Float32Array|Float64Array|number[]} out
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ */
+export function shoot_normalize3(out, x, y, z) {
+    const len = Math.hypot(x, y, z);
+    if (len > 1e-9) {
+        out[0] = x / len;
+        out[1] = y / len;
+        out[2] = z / len;
+    } else {
+        out[0] = 0;
+        out[1] = 1;
+        out[2] = 0;
+    }
+}
+
+/**
+ * A unit vector perpendicular to unit `(x, y, z)`.
+ * @param {Float32Array|Float64Array|number[]} out
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ */
+export function shoot_perpendicular3(out, x, y, z) {
+    // cross with whichever axis is least aligned
+    if (Math.abs(x) < 0.9) {
+        shoot_normalize3(out, 0, z, -y);
+    } else {
+        shoot_normalize3(out, -z, 0, x);
+    }
+}
+
+/**
+ * Direction out of the crown and up at a point, as the foliage's phototropism reads it.
+ * @param {Float32Array|Float64Array|number[]} out
+ * @param {import("./TreeSkeleton.js").TreeSkeleton} skeleton
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ */
+export function shoot_outward3(out, skeleton, x, y, z) {
+    shoot_normalize3(
+        out,
+        x - skeleton.crown_center[0],
+        y - skeleton.crown_center[1] + 0.35 * skeleton.crown_radii[1],
+        z - skeleton.crown_center[2]
+    );
+}
+
+/**
+ * The segment of a branch chain containing `t`, and where on it.
+ * @param {import("./TreeSkeleton.js").TreeSkeleton} skeleton
+ * @param {number[]} nodes
+ * @param {number[]} edges
+ * @param {number} t
+ * @returns {{edge: number, u: number}}
+ */
+export function shoot_locate_on_chain(skeleton, nodes, edges, t) {
+    for (let i = 0; i < edges.length; i++) {
+        const t0 = skeleton.node_t_norm(nodes[i]);
+        const t1 = skeleton.node_t_norm(nodes[i + 1]);
+        if (t <= t1 || i === edges.length - 1) {
+            return { edge: edges[i], u: clamp((t - t0) / Math.max(1e-6, t1 - t0), 0, 1) };
+        }
+    }
+    return { edge: edges[edges.length - 1], u: 1 };
+}

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

@@ -0,0 +1,166 @@
+/**
+ * @typedef {Object} ShootCarrier
+ * @property {import("../config/ShootSystemRule.js").ShootSystemRule} rule
+ * @property {number} carrier framework branch
+ * @property {number} length metres
+ * @property {number[]} nodes the carrier's chain
+ * @property {number[]} edges
+ * @property {number[]} units lengths (m) of its last annual units, oldest first, ending at its tip
+ * @property {Float64Array} starts arc length (m) from its base where each unit starts
+ * @property {Float64Array} points world position of each unit boundary, `(units + 1) * 3`, the last its tip
+ * @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
+ */
+/**
+ * @typedef {Object} ShootAxis
+ * @property {number} system index of its carrier
+ * @property {number} parent mother axis, `-1` for the carrier
+ * @property {number} parent_unit unit of the mother it grew from, oldest first
+ * @property {number} u where along that unit, 0 base to 1 tip
+ * @property {number} node bud index on that unit, for the leaf spiral
+ * @property {number} order branching order, the carrier being `rule.carrier_order`
+ * @property {boolean} short a short shoot
+ * @property {number} generator its branch generator
+ * @property {number} phase random phase in [0, 1)
+ * @property {number[]} units lengths (m), oldest first
+ * @property {number[]} unit_seasons season each unit grew in
+ * @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
+ */
+/**
+ * Grows the twig systems of every carrier together, season by season, in the light their leaves make for each other,
+ * for `seasons` seasons: the tree's age, so every unit of every carrier has had the time since it grew to grow its
+ * twigs.
+ *
+ * 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.
+ * 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
+ *    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
+ *    equally lit shoots an established axis outlasts a new lateral. A shed terminal sheds its whole axis with
+ *    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.
+ *
+ * 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
+ * shoot whose wood the framework, or its own girth, has grown into by the end of a season is engulfed and dies with
+ * everything on it.
+ *
+ * @param {import("./TreeSkeleton.js").TreeSkeleton} skeleton
+ * @param {import("../config/TreeSpeciesConfig.js").TreeSpeciesConfig} species
+ * @param {ShootCarrier[]} carriers
+ * @param {number} seasons
+ * @param {function():number} rng
+ * @returns {ShootAxis[]} the living axes, a mother before its laterals
+ */
+export function shoot_systems_simulate(skeleton: import("./TreeSkeleton.js").TreeSkeleton, species: import("../config/TreeSpeciesConfig.js").TreeSpeciesConfig, carriers: ShootCarrier[], seasons: number, rng: () => number): ShootAxis[];
+export type ShootCarrier = {
+    rule: import("../config/ShootSystemRule.js").ShootSystemRule;
+    /**
+     * framework branch
+     */
+    carrier: number;
+    /**
+     * metres
+     */
+    length: number;
+    /**
+     * the carrier's chain
+     */
+    nodes: number[];
+    edges: number[];
+    /**
+     * lengths (m) of its last annual units, oldest first, ending at its tip
+     */
+    units: number[];
+    /**
+     * arc length (m) from its base where each unit starts
+     */
+    starts: Float64Array;
+    /**
+     * world position of each unit boundary, `(units + 1) * 3`, the last its tip
+     */
+    points: Float64Array;
+    /**
+     * season its oldest unit grew in
+     */
+    first_season: number;
+    /**
+     * pipe area of what grows on each unit, after the simulation
+     */
+    carrier_area?: Float64Array;
+    /**
+     * radius each unit needs where its laterals join, after the simulation
+     */
+    carrier_demand?: Float64Array;
+};
+export type ShootAxis = {
+    /**
+     * index of its carrier
+     */
+    system: number;
+    /**
+     * mother axis, `-1` for the carrier
+     */
+    parent: number;
+    /**
+     * unit of the mother it grew from, oldest first
+     */
+    parent_unit: number;
+    /**
+     * where along that unit, 0 base to 1 tip
+     */
+    u: number;
+    /**
+     * bud index on that unit, for the leaf spiral
+     */
+    node: number;
+    /**
+     * branching order, the carrier being `rule.carrier_order`
+     */
+    order: number;
+    /**
+     * a short shoot
+     */
+    short: boolean;
+    /**
+     * its branch generator
+     */
+    generator: number;
+    /**
+     * random phase in [0, 1)
+     */
+    phase: number;
+    /**
+     * lengths (m), oldest first
+     */
+    units: number[];
+    /**
+     * season each unit grew in
+     */
+    unit_seasons: number[];
+    /**
+     * world position of each unit boundary, `(units + 1) * 3`
+     */
+    points: number[];
+    /**
+     * radius (m) of the wood at each unit boundary, `units + 1`
+     */
+    radii: number[];
+    /**
+     * carrier segment a first-order axis grows from, else -1
+     */
+    anchor_edge: number;
+};
+//# sourceMappingURL=shoot_systems_simulate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shoot_systems_simulate.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/skeleton/shoot_systems_simulate.js"],"names":[],"mappings":"AAgCA;;;;;;;;;;;;;GAaG;AAEH;;;;;;;;;;;;;;;;GAgBG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,iDAPW,OAAO,mBAAmB,EAAE,YAAY,WACxC,OAAO,gCAAgC,EAAE,iBAAiB,YAC1D,YAAY,EAAE,WACd,MAAM,aACK,MAAM,GACf,SAAS,EAAE,CAwWvB;;UAxaa,OAAO,8BAA8B,EAAE,eAAe;;;;aACtD,MAAM;;;;YACN,MAAM;;;;WACN,MAAM,EAAE;WACR,MAAM,EAAE;;;;WACR,MAAM,EAAE;;;;YACR,YAAY;;;;YACZ,YAAY;;;;kBACZ,MAAM;;;;mBACN,YAAY;;;;qBACZ,YAAY;;;;;;YAKZ,MAAM;;;;YACN,MAAM;;;;iBACN,MAAM;;;;OACN,MAAM;;;;UACN,MAAM;;;;WACN,MAAM;;;;WACN,OAAO;;;;eACP,MAAM;;;;WACN,MAAM;;;;WACN,MAAM,EAAE;;;;kBACR,MAAM,EAAE;;;;YACR,MAAM,EAAE;;;;WACR,MAAM,EAAE;;;;iBACR,MAAM"}