@woosh/meep-engine 3.58.0 → 3.60.0

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

@@ -0,0 +1,171 @@
+const SCRATCH_P = new Float64Array(3);
+const SCRATCH_T = new Float64Array(3);
+const SCRATCH_R = new Float64Array(3);
+const SCRATCH_V = new Float64Array(3);
+const SCRATCH_NODES = [];
+const SCRATCH_EDGES = [];
+
+/**
+ * @typedef {Object} TreeBranchPlacement where a copied branch goes, when not where it was: `p' = to + scale turn (p - from)`
+ * @property {ArrayLike<number>} turn row-major 3x3 rotation, turning its spine, frames, tangents and scars
+ * @property {number} scale uniform: positions about `from`, arc and segment lengths, and girth
+ * @property {ArrayLike<number>} from the point placed at `to`
+ * @property {ArrayLike<number>} to
+ */
+
+/**
+ * Copies branch `b` of `source`, with its nodes, segments, annual units, scars and dead flag, into `out`, hanging from
+ * `parent` there (or starting a tree of its own when `-1`) at `attach_t` on its segment `parent_edge`, its first node
+ * from `hang`, at depth `level`; carried by `placement` if given. The wind rig's joints are not copied: the rig is
+ * assigned to `out` as a whole.
+ *
+ * @param {import("./TreeSkeleton.js").TreeSkeleton} source
+ * @param {number} b
+ * @param {import("./TreeSkeleton.js").TreeSkeleton} out
+ * @param {number} parent branch in `out`, or `-1`
+ * @param {number} parent_edge segment of `parent` in `out`, or `-1`
+ * @param {number} attach_t where along `parent`, as `t_norm`
+ * @param {number} hang node of `out` its first node hangs from, or `-1`
+ * @param {number} level
+ * @param {TreeBranchPlacement|null} placement
+ * @param {Map<number, number>} edge_of receives each copied segment's id in `out`, by its id in `source`
+ * @returns {number} its id in `out`
+ */
+export function tree_skeleton_copy_branch(source, b, out, parent, parent_edge, attach_t, hang, level, placement, edge_of) {
+    const m0 = source.attr_segment_hermite_m0.data;
+    const m1 = source.attr_segment_hermite_m1.data;
+    const scale = placement !== null ? placement.scale : 1;
+    source.collect_branch_chain(b, SCRATCH_NODES, SCRATCH_EDGES);
+    const id = out.add_branch(0, level, source.branch_generator[b], parent, parent_edge, attach_t,
+        source.branch_length[b] * scale, source.branch_base_radius[b] * scale, source.branch_phase_hash[b]);
+    out.branch_dead[id] = source.branch_dead[b];
+
+    let prev = -1;
+    for (let k = 0; k < SCRATCH_NODES.length; k++) {
+        const v = SCRATCH_NODES[k];
+        source.node_read_position(SCRATCH_P, 0, v);
+        source.node_read_tangent(SCRATCH_T, 0, v);
+        source.node_read_frame_r(SCRATCH_R, 0, v);
+        if (placement !== null) {
+            tree_branch_placement_apply(SCRATCH_P, placement);
+            tree_branch_turn(SCRATCH_T, placement.turn);
+            tree_branch_turn(SCRATCH_R, placement.turn);
+        }
+        const w = out.add_node(SCRATCH_P[0], SCRATCH_P[1], SCRATCH_P[2], SCRATCH_T[0], SCRATCH_T[1], SCRATCH_T[2],
+            SCRATCH_R[0], SCRATCH_R[1], SCRATCH_R[2], source.node_read_radius(v) * scale, id, level, parent,
+            source.node_t_norm(v), source.node_arc_s(v) * scale, source.node_phase_hash(v));
+        if (k === 0) {
+            out.branch_root_vertex[id] = w;
+            if (hang >= 0) out.connect_nodes(hang, w);
+        } else {
+            const e = SCRATCH_EDGES[k - 1];
+            const o = e * 3;
+            SCRATCH_T[0] = m0[o];
+            SCRATCH_T[1] = m0[o + 1];
+            SCRATCH_T[2] = m0[o + 2];
+            SCRATCH_V[0] = m1[o];
+            SCRATCH_V[1] = m1[o + 1];
+            SCRATCH_V[2] = m1[o + 2];
+            if (placement !== null) {
+                tree_branch_turn(SCRATCH_T, placement.turn);
+                tree_branch_turn(SCRATCH_V, placement.turn);
+                for (let d = 0; d < 3; d++) {
+                    SCRATCH_T[d] *= scale;
+                    SCRATCH_V[d] *= scale;
+                }
+            }
+            edge_of.set(e, out.add_segment(prev, w, SCRATCH_T[0], SCRATCH_T[1], SCRATCH_T[2],
+                SCRATCH_V[0], SCRATCH_V[1], SCRATCH_V[2], source.segment_length(e) * scale, source.segment_parent_attach_t(e)));
+        }
+        prev = w;
+    }
+    out.branch_tip_vertex[id] = prev;
+
+    const unit_count = source.branch_unit_count[b];
+    if (unit_count > 0) {
+        const offset = source.branch_unit_offset[b];
+        out.set_branch_units(id, source.unit_start_t.subarray(offset, offset + unit_count));
+    }
+    for (let s = 0; s < source.scar_count; s++) {
+        if (source.scar_branch[s] !== b) continue;
+        const d = s * 5;
+        SCRATCH_V[0] = source.scar_data[d + 1];
+        SCRATCH_V[1] = source.scar_data[d + 2];
+        SCRATCH_V[2] = source.scar_data[d + 3];
+        if (placement !== null) tree_branch_turn(SCRATCH_V, placement.turn);
+        out.add_scar(id, source.scar_data[d], SCRATCH_V[0], SCRATCH_V[1], SCRATCH_V[2], source.scar_data[d + 4] * scale);
+    }
+    return id;
+}
+
+/**
+ * Copies `branches` of `source` into `out`, where they are (`tree_skeleton_copy_branch`). A branch whose parent is
+ * copied before it hangs from that parent's copy, from the node the original hung from; any other starts a tree of its
+ * own in `out`, at the level it had.
+ *
+ * A species' prototypes are gathered from the trees they grew in this way (`tree_shoot_prototypes`).
+ *
+ * @param {import("./TreeSkeleton.js").TreeSkeleton} source
+ * @param {ArrayLike<number>} branches parents before their children
+ * @param {import("./TreeSkeleton.js").TreeSkeleton} out
+ * @returns {Int32Array} each copied branch's id in `out`, in the order of `branches`
+ */
+export function tree_skeleton_copy_branches(source, branches, out) {
+    const copied = new Int32Array(branches.length);
+    const branch_of = new Map();
+    const edge_of = new Map();
+    const nodes = [];
+    const edges = [];
+    for (let i = 0; i < branches.length; i++) {
+        const b = branches[i];
+        const parent_src = source.branch_parent[b];
+        const inside = branch_of.has(parent_src);
+        let hang = -1;
+        if (inside) {
+            // the node of its parent it hung from, by its place on the parent's chain
+            const hung = source.node_parent_vertex(source.branch_root_vertex[b]);
+            source.collect_branch_chain(parent_src, nodes, edges);
+            const at = nodes.indexOf(hung);
+            if (at >= 0) {
+                out.collect_branch_chain(branch_of.get(parent_src), nodes, edges);
+                hang = nodes[at];
+            }
+        }
+        const id = tree_skeleton_copy_branch(source, b, out,
+            inside ? branch_of.get(parent_src) : -1,
+            inside ? edge_of.get(source.branch_parent_edge[b]) : -1,
+            inside ? source.branch_parent_attach_t[b] : 0,
+            hang, source.branch_level[b], null, edge_of);
+        branch_of.set(b, id);
+        copied[i] = id;
+    }
+    return copied;
+}
+
+/**
+ * `v = M v`: a direction carried by a placement's `turn`.
+ * @param {Float64Array|number[]} v
+ * @param {ArrayLike<number>} m row-major 3x3
+ */
+export function tree_branch_turn(v, m) {
+    const x = v[0], y = v[1], z = v[2];
+    v[0] = m[0] * x + m[1] * y + m[2] * z;
+    v[1] = m[3] * x + m[4] * y + m[5] * z;
+    v[2] = m[6] * x + m[7] * y + m[8] * z;
+}
+
+/**
+ * `p = to + scale turn (p - from)`: a point carried by `placement`.
+ * @param {Float64Array|number[]} p
+ * @param {TreeBranchPlacement} placement
+ */
+export function tree_branch_placement_apply(p, placement) {
+    const { from, to, scale } = placement;
+    p[0] -= from[0];
+    p[1] -= from[1];
+    p[2] -= from[2];
+    tree_branch_turn(p, placement.turn);
+    p[0] = to[0] + scale * p[0];
+    p[1] = to[1] + scale * p[1];
+    p[2] = to[2] + scale * p[2];
+}

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

@@ -0,0 +1,17 @@
+/**
+ * Extends `branch` past its tip along `points`, a node at each and a segment between, as long as `lengths` says (an
+ * annual unit's length, which its chord may fall short of): the shoot simulation
+ * grows a carrier on this way, and a graft carries a prototype's extension onto its host's carrier. Its nodes, the
+ * branches it carries and its scars keep their place along it as it grows longer: their `t_norm` shrinks by its old
+ * length over its new.
+ *
+ * @param {import("./TreeSkeleton.js").TreeSkeleton} skeleton
+ * @param {number} branch
+ * @param {ArrayLike<number>} points `3 (n + 1)`: its tip, then each new node
+ * @param {ArrayLike<number>} radii `n + 1`, at each of `points`
+ * @param {ArrayLike<number>} lengths `n`, m, each new segment's
+ * @param {number[]} [out_edges] receives the new segments, base first
+ * @returns {number} its new length
+ */
+export function tree_skeleton_extend_branch(skeleton: import("./TreeSkeleton.js").TreeSkeleton, branch: number, points: ArrayLike<number>, radii: ArrayLike<number>, lengths: ArrayLike<number>, out_edges?: number[]): number;
+//# sourceMappingURL=tree_skeleton_extend_branch.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tree_skeleton_extend_branch.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/skeleton/tree_skeleton_extend_branch.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;GAcG;AACH,sDARW,OAAO,mBAAmB,EAAE,YAAY,UACxC,MAAM,UACN,UAAU,MAAM,CAAC,SACjB,UAAU,MAAM,CAAC,WACjB,UAAU,MAAM,CAAC,cACjB,MAAM,EAAE,GACN,MAAM,CAyDlB"}

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

@@ -0,0 +1,79 @@
+import { spine_frame_double_reflection } from "./spine_frame_double_reflection.js";
+
+const SCRATCH_R = new Float32Array(3);
+const SCRATCH_T = new Float32Array(3);
+const SCRATCH_RMF = new Float64Array(6);
+const SCRATCH_NODES = [];
+const SCRATCH_EDGES = [];
+
+/**
+ * Extends `branch` past its tip along `points`, a node at each and a segment between, as long as `lengths` says (an
+ * annual unit's length, which its chord may fall short of): the shoot simulation
+ * grows a carrier on this way, and a graft carries a prototype's extension onto its host's carrier. Its nodes, the
+ * branches it carries and its scars keep their place along it as it grows longer: their `t_norm` shrinks by its old
+ * length over its new.
+ *
+ * @param {import("./TreeSkeleton.js").TreeSkeleton} skeleton
+ * @param {number} branch
+ * @param {ArrayLike<number>} points `3 (n + 1)`: its tip, then each new node
+ * @param {ArrayLike<number>} radii `n + 1`, at each of `points`
+ * @param {ArrayLike<number>} lengths `n`, m, each new segment's
+ * @param {number[]} [out_edges] receives the new segments, base first
+ * @returns {number} its new length
+ */
+export function tree_skeleton_extend_branch(skeleton, branch, points, radii, lengths, out_edges) {
+    const old_length = skeleton.branch_length[branch];
+    const n = lengths.length;
+    let added = 0;
+    for (let k = 0; k < n; k++) added += lengths[k];
+    const length = old_length + added;
+    const scale = old_length / length;
+
+    skeleton.collect_branch_chain(branch, SCRATCH_NODES, SCRATCH_EDGES);
+    for (let i = 0; i < SCRATCH_NODES.length; i++) {
+        skeleton.node_write_t_norm(SCRATCH_NODES[i], skeleton.node_t_norm(SCRATCH_NODES[i]) * scale);
+    }
+    for (let child = 0; child < skeleton.branch_count; child++) {
+        if (skeleton.branch_parent[child] === branch) skeleton.branch_parent_attach_t[child] *= scale;
+    }
+    for (let i = 0; i < skeleton.scar_count; i++) {
+        if (skeleton.scar_branch[i] === branch) skeleton.scar_data[i * 5] *= scale;
+    }
+
+    const level = skeleton.branch_level[branch];
+    const parent_branch = skeleton.branch_parent[branch];
+    const phase = skeleton.branch_phase_hash[branch];
+    let prev_v = skeleton.branch_tip_vertex[branch];
+    const arc_base = skeleton.node_arc_s(prev_v);
+    skeleton.node_read_frame_r(SCRATCH_R, 0, prev_v);
+    let rx = SCRATCH_R[0], ry = SCRATCH_R[1], rz = SCRATCH_R[2];
+    skeleton.node_read_tangent(SCRATCH_T, 0, prev_v);
+    let tx = SCRATCH_T[0], ty = SCRATCH_T[1], tz = SCRATCH_T[2];
+    let px = points[0], py = points[1], pz = points[2];
+    let arc = old_length;
+    for (let k = 0; k < n; k++) {
+        const nx = points[(k + 1) * 3], ny = points[(k + 1) * 3 + 1], nz = points[(k + 1) * 3 + 2];
+        const len = lengths[k];
+        const d = Math.max(1e-9, Math.hypot(nx - px, ny - py, nz - pz));
+        const ntx = (nx - px) / d, nty = (ny - py) / d, ntz = (nz - pz) / d;
+        spine_frame_double_reflection(SCRATCH_RMF, 0, px, py, pz, tx, ty, tz, rx, ry, rz, nx, ny, nz, ntx, nty, ntz);
+        rx = SCRATCH_RMF[0];
+        ry = SCRATCH_RMF[1];
+        rz = SCRATCH_RMF[2];
+        tx = ntx;
+        ty = nty;
+        tz = ntz;
+        const t_prev = arc / length;
+        arc += len;
+        const curr_v = skeleton.add_node(nx, ny, nz, tx, ty, tz, rx, ry, rz, radii[k + 1], branch, level, parent_branch, arc / length, arc_base + arc - old_length, phase);
+        const e = skeleton.add_segment(prev_v, curr_v, tx * len, ty * len, tz * len, tx * len, ty * len, tz * len, len, t_prev);
+        if (out_edges !== undefined) out_edges.push(e);
+        prev_v = curr_v;
+        px = nx;
+        py = ny;
+        pz = nz;
+    }
+    skeleton.branch_tip_vertex[branch] = prev_v;
+    skeleton.branch_length[branch] = length;
+    return length;
+}

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

@@ -0,0 +1,12 @@
+/**
+ * Fits the skeleton's crown frame (`crown_center`, `crown_radii`), which the foliage and the crown's shading read, to the
+ * crown as grown: centred on, and spanning, every living branch a shoot rule grows on or grows (its `source`, its
+ * `target`s and its `short_target`). Both front ends end on it, so the frame follows one law however the tree grew:
+ * the graph's carriers alone, or the carriers with the shoot systems on them. A species without shoot rules keeps the
+ * frame its envelope set.
+ *
+ * @param {import("./TreeSkeleton.js").TreeSkeleton} skeleton
+ * @param {import("../config/TreeSpeciesConfig.js").TreeSpeciesConfig} species
+ */
+export function tree_skeleton_fit_crown_frame(skeleton: import("./TreeSkeleton.js").TreeSkeleton, species: import("../config/TreeSpeciesConfig.js").TreeSpeciesConfig): void;
+//# sourceMappingURL=tree_skeleton_fit_crown_frame.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tree_skeleton_fit_crown_frame.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/skeleton/tree_skeleton_fit_crown_frame.js"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,wDAHW,OAAO,mBAAmB,EAAE,YAAY,WACxC,OAAO,gCAAgC,EAAE,iBAAiB,QA6BpE"}

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

@@ -0,0 +1,56 @@
+const SCRATCH_P = new Float32Array(3);
+
+/**
+ * Fits the skeleton's crown frame (`crown_center`, `crown_radii`), which the foliage and the crown's shading read, to the
+ * crown as grown: centred on, and spanning, every living branch a shoot rule grows on or grows (its `source`, its
+ * `target`s and its `short_target`). Both front ends end on it, so the frame follows one law however the tree grew:
+ * the graph's carriers alone, or the carriers with the shoot systems on them. A species without shoot rules keeps the
+ * frame its envelope set.
+ *
+ * @param {import("./TreeSkeleton.js").TreeSkeleton} skeleton
+ * @param {import("../config/TreeSpeciesConfig.js").TreeSpeciesConfig} species
+ */
+export function tree_skeleton_fit_crown_frame(skeleton, species) {
+    const rules = species.shoot_rules;
+    if (rules.length === 0) {
+        return;
+    }
+    let x0 = Infinity, y0 = Infinity, z0 = Infinity, x1 = -Infinity, y1 = -Infinity, z1 = -Infinity;
+    for (let v = 0; v < skeleton.node_count; v++) {
+        const b = skeleton.node_branch_id(v);
+        if (skeleton.branch_dead[b] || !shoot_generator(rules, skeleton.branch_generator[b])) continue;
+        skeleton.node_read_position(SCRATCH_P, 0, v);
+        x0 = Math.min(x0, SCRATCH_P[0]);
+        y0 = Math.min(y0, SCRATCH_P[1]);
+        z0 = Math.min(z0, SCRATCH_P[2]);
+        x1 = Math.max(x1, SCRATCH_P[0]);
+        y1 = Math.max(y1, SCRATCH_P[1]);
+        z1 = Math.max(z1, SCRATCH_P[2]);
+    }
+    if (!(x1 >= x0)) {
+        // nothing a shoot rule grows on is alive
+        return;
+    }
+    skeleton.crown_center[0] = 0.5 * (x0 + x1);
+    skeleton.crown_center[1] = 0.5 * (y0 + y1);
+    skeleton.crown_center[2] = 0.5 * (z0 + z1);
+    skeleton.crown_radii[0] = Math.max(0.25, 0.5 * (x1 - x0));
+    skeleton.crown_radii[1] = Math.max(0.25, 0.5 * (y1 - y0));
+    skeleton.crown_radii[2] = Math.max(0.25, 0.5 * (z1 - z0));
+}
+
+/**
+ * Whether a shoot rule grows on, or grows, branches of `generator`.
+ * @param {import("../config/ShootSystemRule.js").ShootSystemRule[]} rules
+ * @param {number} generator
+ * @returns {boolean}
+ */
+function shoot_generator(rules, generator) {
+    for (let r = 0; r < rules.length; r++) {
+        const rule = rules[r];
+        if (rule.source === generator || rule.target.includes(generator)) return true;
+        // its short shoots, if it grows any
+        if (rule.short_target === generator && rule.zones.some(z => z.short.some(p => p > 0))) return true;
+    }
+    return false;
+}

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

@@ -0,0 +1,11 @@
+/**
+ * Raises every branch to at least the girth of what grows from it: where a living branch hangs, its parent is at least
+ * as thick as its base, and no branch thickens towards its tip. Only ever raises. A tree whose wood came from different
+ * growths (a graph tree's framework with its shoot prototypes' carriers, `tree_shoot_instances`) holds together by it.
+ *
+ * Children must come after their parents, as every grower writes them.
+ *
+ * @param {import("./TreeSkeleton.js").TreeSkeleton} skeleton
+ */
+export function tree_skeleton_floor_girth(skeleton: import("./TreeSkeleton.js").TreeSkeleton): void;
+//# sourceMappingURL=tree_skeleton_floor_girth.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tree_skeleton_floor_girth.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/skeleton/tree_skeleton_floor_girth.js"],"names":[],"mappings":"AAGA;;;;;;;;GAQG;AACH,oDAFW,OAAO,mBAAmB,EAAE,YAAY,QA2BlD"}

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

@@ -0,0 +1,38 @@
+const SCRATCH_NODES = [];
+const SCRATCH_EDGES = [];
+
+/**
+ * Raises every branch to at least the girth of what grows from it: where a living branch hangs, its parent is at least
+ * as thick as its base, and no branch thickens towards its tip. Only ever raises. A tree whose wood came from different
+ * growths (a graph tree's framework with its shoot prototypes' carriers, `tree_shoot_instances`) holds together by it.
+ *
+ * Children must come after their parents, as every grower writes them.
+ *
+ * @param {import("./TreeSkeleton.js").TreeSkeleton} skeleton
+ */
+export function tree_skeleton_floor_girth(skeleton) {
+    // the thickest living child hanging on each segment, by its base
+    const hung = new Float64Array(skeleton.segment_count);
+    for (let b = skeleton.branch_count - 1; b >= 0; b--) {
+        skeleton.collect_branch_chain(b, SCRATCH_NODES, SCRATCH_EDGES);
+        const n = SCRATCH_NODES.length;
+        if (n === 0) continue;
+        // from the tip to the base: as thick as anything further out on it, and, at both ends of a segment, as anything
+        // hanging from it
+        let need = 0;
+        for (let i = n - 1; i >= 0; i--) {
+            const v = SCRATCH_NODES[i];
+            if (i < n - 1) need = Math.max(need, hung[SCRATCH_EDGES[i]]);
+            if (i > 0) need = Math.max(need, hung[SCRATCH_EDGES[i - 1]]);
+            const r = skeleton.node_read_radius(v);
+            if (need > r) skeleton.node_write_radius(v, need);
+            else need = r;
+        }
+        skeleton.branch_base_radius[b] = Math.max(skeleton.branch_base_radius[b], skeleton.node_read_radius(SCRATCH_NODES[0]));
+        // its base, on the segment of its parent it hangs from
+        const edge = skeleton.branch_parent_edge[b];
+        if (edge >= 0 && !skeleton.branch_dead[b]) {
+            hung[edge] = Math.max(hung[edge], skeleton.node_read_radius(SCRATCH_NODES[0]));
+        }
+    }
+}

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

@@ -1,15 +1,8 @@
 /**
- * Generates a directed botanical `TreeSkeleton` from a `TreeSpeciesConfig`, combining:
- * - A branch generator graph: `species.branches[0]` grows the trunk, and every `species.branch_rules` edge
- *   spawns branches of its `target` generator along each branch of its `source` generator
- * - Parametric Cubic Hermite spine generation (`BranchGeneratorConfig`, `AnimationCurve` profiles)
- * - Botanical phyllotaxis (`SpiralGolden`, `AlternateDistichous`, `Tristichous`, `Opposite`, `OppositeDecussate`, `Whorled`, `FlareLobes`)
- * - Structural surface roots (`BranchGeneratorConfig.root`) that creep along the ground plane `y = 0`
- * - Gravitropism (toward `-Y`), phototropism (toward `+Y` and outward crown exterior), and 3D `curl_noise_3d` gnarl
- * - Dichotomous / sympodial trunk & bough splitting
- * - Space colonization crown competition via `PointHashGrid3`
- * - Rotation-Minimizing Frames (`spine_frame_double_reflection`)
- * - Pipe Model cross-section radius accumulation (`tree_skeleton_compute_pipe_radii`)
+ * Grows a whole tree botanically (`TreeGrowth.Botanical`): its framework from the generator graph
+ * (`tree_skeleton_grow_framework`), then the shoot systems of its `shoot_rules`, year by year on that framework, its
+ * girth final (`tree_skeleton_grow_shoots`), and fits the crown frame to them as the framework did to its carriers
+ * (`tree_skeleton_fit_crown_frame`).
  *
  * @param {TreeSpeciesConfig|Object} [config]
  * @param {TreeSkeleton} [out]

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

@@ -1 +1 @@
-{"version":3,"file":"tree_skeleton_grow.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/skeleton/tree_skeleton_grow.js"],"names":[],"mappings":"AA8RA;;;;;;;;;;;;;;;;GAgBG;AACH,4CAJW,iBAAiB,MAAO,QACxB,YAAY,GACV,YAAY,CAmtDxB;kCAr/DiC,gCAAgC;6BACrC,mBAAmB"}
+{"version":3,"file":"tree_skeleton_grow.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/skeleton/tree_skeleton_grow.js"],"names":[],"mappings":"AAMA;;;;;;;;;GASG;AACH,4CAJW,iBAAiB,MAAO,QACxB,YAAY,GACV,YAAY,CAQxB;kCAtBiC,gCAAgC;6BACrC,mBAAmB"}