@woosh/meep-engine 3.58.0 → 3.60.0

package/src/generation/foliage/mesh/tree_mesh_build_bark.js

@@ -41,6 +41,12 @@ const SCRATCH_PARENT_T = new Float32Array(3);
 const SCRATCH_COLLAR_POS = new Float32Array(3);
 const SCRATCH_COLLAR_NORM = new Float32Array(3);
 const SCRATCH_RELIEF = new Float32Array(4);
+/**
+ * Per node of the branch being meshed, the joint its span moves with alone, or -1 (`tree_mesh_build_bark`).
+ * @type {Int32Array}
+ */
+let SCRATCH_SPAN_JOINT = new Int32Array(64);
+
 const SCRATCH_JOINTS4 = new Int32Array(4);
 const SCRATCH_WEIGHTS4 = new Float64Array(4);
 const SCRATCH_SHAPE = new Float64Array(4);
@@ -868,6 +874,25 @@ export function tree_mesh_build_bark(
             base_w3 = SCRATCH_WEIGHTS4[3];
         }
 
+        // The branch's joint spans, each run of its nodes bound to one joint, and how each is carried. A joint turns its
+        // whole span about its pivot, as the rig derived it (`tree_skeleton_assign_skin_joints`): a span that starts at
+        // its joint's pivot moves with that joint alone. The bark is then continuous across every pivot, which the joint
+        // turning it does not move, and a child's joint pivots where the bark it grows from carries it. Blending a span
+        // with the joints above it tears the bark at the pivot that ends it. A span of a joint pivoted further up (a child
+        // before its own first joint) is carried as the parent's bark carries the child's base.
+        // per node, the joint its span moves with alone, or -1 where the parent's bark carries it
+        if (SCRATCH_SPAN_JOINT.length < E + 1) SCRATCH_SPAN_JOINT = new Int32Array(2 * (E + 1));
+        const span_joint = SCRATCH_SPAN_JOINT;
+        for (let k = 0; k <= E;) {
+            const joint = skeleton.node_read_joint(nodes[k], 0);
+            let e = k;
+            while (e < E && skeleton.node_read_joint(nodes[e + 1], 0) === joint) e++;
+            // a run of a joint starts at that joint's pivot, if the joint is the branch's own
+            const own = !has_meshed_parent || skeleton.joint_vertex[joint] === nodes[k];
+            for (let n = k; n <= e; n++) span_joint[n] = own ? joint : -1;
+            k = e + 1;
+        }
+
         let prev_ring_start = -1;
         let prev_m = 0;
         const current_branch_rings = [];
@@ -973,60 +998,13 @@ export function tree_mesh_build_bark(
             const arc_s = lerp(SCRATCH_SPINE0[1], SCRATCH_SPINE1[1], local_u);
             const phase_hash = skeleton.branch_phase_hash[b];
 
-            // Skinning joint indices & weights at this ring (causal upstream-only + <= 4 joints per frustum slice)
-            let ring_j0 = 0, ring_j1 = 0, ring_j2 = 0, ring_j3 = 0;
-            let ring_w0 = 1.0, ring_w1 = 0.0, ring_w2 = 0.0, ring_w3 = 0.0;
-            if (has_meshed_parent) {
-                const parent_attach_v = skeleton.node_parent_vertex(nodes[0]);
-                const ancestor_j = parent_attach_v >= 0 ? skeleton.node_read_joint(parent_attach_v, 0) : 0;
-                const j_branch_root = skeleton.node_read_joint(nodes[0], 0);
-                const j_v0 = skeleton.node_read_joint(v0, 0);
-                if (i === 0 || j_v0 === ancestor_j) {
-                    ring_j0 = base_j0;
-                    ring_j1 = base_j1;
-                    ring_j2 = base_j2;
-                    ring_j3 = base_j3;
-                    ring_w0 = base_w0;
-                    ring_w1 = base_w1;
-                    ring_w2 = base_w2;
-                    ring_w3 = base_w3;
-                } else if (j_v0 === j_branch_root) {
-                    const w_own = clamp(0.85 * t_norm, 0.0, 0.90);
-                    const w_base = 1.0 - w_own;
-                    ring_j0 = j_v0;
-                    ring_j1 = base_j0;
-                    ring_j2 = base_j1;
-                    ring_j3 = 0;
-                    ring_w0 = w_own;
-                    ring_w1 = w_base * base_w0;
-                    ring_w2 = w_base * base_w1;
-                    ring_w3 = 0.0;
-                    const rw_sum = ring_w0 + ring_w1 + ring_w2;
-                    if (rw_sum > 1e-6) {
-                        ring_w0 /= rw_sum;
-                        ring_w1 /= rw_sum;
-                        ring_w2 /= rw_sum;
-                    }
-                } else {
-                    const w_own = clamp(0.50 + 0.45 * t_norm, 0.0, 0.95);
-                    ring_j0 = j_v0;
-                    ring_j1 = j_branch_root;
-                    ring_j2 = 0;
-                    ring_j3 = 0;
-                    ring_w0 = w_own;
-                    ring_w1 = 1.0 - w_own;
-                    ring_w2 = 0.0;
-                    ring_w3 = 0.0;
-                }
-            } else {
-                const j_primary = skeleton.node_read_joint(v0, 0);
-                const j_parent = skeleton.node_read_joint(v0, 1);
-                const w_primary = (v0 === 0 || j_primary === j_parent) ? 1.0 : clamp(0.25 + 0.75 * t_norm, 0.0, 1.0);
-                ring_j0 = j_primary;
-                ring_j1 = j_parent;
-                ring_w0 = w_primary;
-                ring_w1 = 1.0 - w_primary;
-            }
+            // Skinning: the joint whose span the ring is in, alone (`SCRATCH_SPAN_JOINT`); a child's first ring is seated in its parent's
+            // bark and carried as that bark carries it
+            const joint = i === 0 && has_meshed_parent ? -1 : span_joint[edge_idx];
+            const ring_j0 = joint >= 0 ? joint : base_j0, ring_j1 = joint >= 0 ? 0 : base_j1;
+            const ring_j2 = joint >= 0 ? 0 : base_j2, ring_j3 = joint >= 0 ? 0 : base_j3;
+            const ring_w0 = joint >= 0 ? 1.0 : base_w0, ring_w1 = joint >= 0 ? 0.0 : base_w1;
+            const ring_w2 = joint >= 0 ? 0.0 : base_w2, ring_w3 = joint >= 0 ? 0.0 : base_w3;
 
             // Collar weld factor: i === 0 of every child branch is always seated into its meshed parent frustum
             let weld_factor = 0.0;

package/src/generation/foliage/presets/make_tree_species_preset.d.ts

@@ -3,11 +3,16 @@
  * `TreePreset` archetypes (`Oak`, `Pine`, `Birch`, `Willow`, `Maple`, `Spruce`, `Palm`, `Shrub`, `Fern`),
  * with optional deep parameter overrides.
  *
+ * A species is the same for both front ends but where the botanical one grows its framework from shoots: the pine's,
+ * which grows from its seed, has its own framework for the generator graph.
+ *
  * @param {TreePreset|string} [preset=TreePreset.Oak]
  * @param {Object} [overrides]
+ * @param {TreeGrowth} [growth=TreeGrowth.Botanical] which front end the species is grown by
  * @returns {TreeSpeciesConfig}
  */
-export function make_tree_species_preset(preset?: TreePreset | string, overrides?: any): TreeSpeciesConfig;
+export function make_tree_species_preset(preset?: TreePreset | string, overrides?: any, growth?: TreeGrowth): TreeSpeciesConfig;
 import { TreePreset } from "../config/TreePreset.js";
+import { TreeGrowth } from "../config/TreeGrowth.js";
 import { TreeSpeciesConfig } from "../config/TreeSpeciesConfig.js";
 //# sourceMappingURL=make_tree_species_preset.d.ts.map

package/src/generation/foliage/presets/make_tree_species_preset.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"make_tree_species_preset.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/presets/make_tree_species_preset.js"],"names":[],"mappings":"AAkKA;;;;;;;;GAQG;AACH,kDAJW,UAAU,GAAC,MAAM,oBAEf,iBAAiB,CAs0C7B;2BA1+C0B,yBAAyB;kCAClB,gCAAgC"}
+{"version":3,"file":"make_tree_species_preset.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/presets/make_tree_species_preset.js"],"names":[],"mappings":"AAoTA;;;;;;;;;;;;GAYG;AACH,kDALW,UAAU,GAAC,MAAM,4BAEjB,UAAU,GACR,iBAAiB,CA00C7B;2BAnoD0B,yBAAyB;2BADzB,yBAAyB;kCAElB,gCAAgC"}

package/src/generation/foliage/presets/make_tree_species_preset.js

@@ -3,6 +3,7 @@ import { CrownEnvelopeType } from "../config/CrownEnvelopeType.js";
 import { FoliageBarkType } from "../config/FoliageBarkType.js";
 import { FoliageCardType } from "../config/FoliageCardType.js";
 import { PhyllotaxisMode } from "../config/PhyllotaxisMode.js";
+import { TreeGrowth } from "../config/TreeGrowth.js";
 import { TreePreset } from "../config/TreePreset.js";
 import { TreeSpeciesConfig } from "../config/TreeSpeciesConfig.js";
 import { BranchGeneratorConfig } from "../config/BranchGeneratorConfig.js";
@@ -160,16 +161,165 @@ function make_conifer_leader_rule(target) {
 	});
 }
 
+/**
+ * The pine's framework for the generator graph alone (`TreeGrowth.Graph`), as it was before the shoot simulation grew
+ * the pine from its seed (4a3a41928): the seed-grown pine's stem and boughs, as tall and long as the grown tree's, a
+ * whorl of boughs a year and short branches between the whorls, twigs on both, and the twig system grown year by year
+ * on all three (KK1991, as the spruce's). Its roots and its twig system's shoots are the seed-grown pine's own.
+ * @param {TreeSpeciesConfig} config the seed-grown pine
+ */
+function make_pine_framework(config) {
+	const [stem, bough, roots, twig_system] = config.branches;
+	config.branches = [
+		stem.clone().applyOverrides({
+			segments: 12,
+			length: 11.2,
+			length_variance: 0.05,
+			taper: 0.88,
+			curvature: 0.16,
+			curve_back: -0.10,
+			spiral_twist: 0.22,
+			gnarl_strength: 0.09,
+			gnarl_frequency: 0.32,
+			nodal_kink_strength: 0.18,
+			kink_sharpness: 0.48
+		}),
+		bough.clone().applyOverrides({
+			self_pruning: 0.55, // open-grown Scots pine holds dead lower branches for a while
+			segments: 7,
+			length: 3.8,
+			length_variance: 0.10,
+			radius_ratio: 0.035,
+			taper: 0.85,
+			curvature: 0.16,
+			curve_back: -0.12,
+			gnarl_strength: 0.12,
+			nodal_kink_strength: 0.42,
+			kink_sharpness: 0.55,
+			tip_upcurl: 0.34
+		}),
+		// Inter-whorl branches: short laterals spiralling along the internodes between whorls
+		BranchGeneratorConfig.from({
+			self_pruning: 0.55, // open-grown Scots pine holds dead lower branches for a while
+			segments: 5,
+			length: 1.9,
+			length_variance: 0.18,
+			radius_ratio: 0.034,
+			taper: 0.86,
+			curvature: 0.14,
+			curve_back: -0.10,
+			gravitropism: 0.26,
+			phototropism: 0.14,
+			gnarl_strength: 0.12,
+			nodal_kink_strength: 0.30,
+			internode_zigzag: 0.10,
+			kink_sharpness: 0.55,
+			tip_upcurl: 0.30,
+			oval_eccentricity: 0.12,
+			bark_displacement: 0.05,
+			collar_weld_rings: 1
+		}),
+		BranchGeneratorConfig.from({
+			segments: 5,
+			length: 1.4,
+			length_variance: 0.14,
+			radius_ratio: 0.032,
+			taper: 0.85,
+			curvature: 0.14,
+			gravitropism: 0.08,
+			phototropism: 0.24,
+			gnarl_strength: 0.12,
+			internode_zigzag: 0.12,
+			tip_upcurl: 0.32,
+			collar_weld_rings: 1
+		}),
+		// 4: surface roots on the flare crests
+		roots,
+		// 5: the twig system
+		twig_system
+	];
+	config.branch_rules = [
+		BranchSpawnRule.from({
+			source: 0,
+			target: 1,
+			count: 32,
+			attach_min: 0.24,
+			phyllotaxis_mode: PhyllotaxisMode.Whorled,
+			whorl_count: 4,
+			azimuth_jitter: 0.16,
+			insertion_angle: 1.34,
+			insertion_angle_variation: 0.08,
+			insertion_angle_profile: AnimationCurve.linear(0, 1.05, 1, 0.52),
+			length_profile: AnimationCurve.linear(0, 1.0, 1, 0.72),
+			parent_kink: 0.0
+		}),
+		BranchSpawnRule.from({
+			source: 0,
+			target: 2,
+			count: 14,
+			attach_min: 0.30,
+			phyllotaxis_mode: PhyllotaxisMode.SpiralGolden,
+			azimuth_jitter: 0.30,
+			insertion_angle: 1.22,
+			insertion_angle_variation: 0.12,
+			insertion_angle_profile: AnimationCurve.linear(0, 1.05, 1, 0.55),
+			length_profile: AnimationCurve.linear(0, 1.0, 1, 0.6),
+			parent_kink: 0.0
+		}),
+		// Whorl boughs and inter-whorl branches both carry the same twigs
+		BranchSpawnRule.from({
+			source: 1,
+			target: 3,
+			count: 7,
+			attach_min: 0.12,
+			phyllotaxis_mode: PhyllotaxisMode.AlternateDistichous,
+			azimuth_jitter: 0.14,
+			insertion_angle: 0.88,
+			insertion_angle_variation: 0.10,
+			length_profile: AnimationCurve.linear(0, 0.95, 1, 0.48)
+		}),
+		BranchSpawnRule.from({
+			source: 2,
+			target: 3,
+			count: 4,
+			attach_min: 0.15,
+			phyllotaxis_mode: PhyllotaxisMode.AlternateDistichous,
+			azimuth_jitter: 0.14,
+			insertion_angle: 0.88,
+			insertion_angle_variation: 0.10,
+			length_profile: AnimationCurve.linear(0, 0.8, 1, 0.45)
+		})
+	];
+	config.branch_rules.push(make_surface_roots_rule(4, config.branches[0].flare_lobes));
+	// Shoots average 11.02 cm on the whorl branches, at most 47.5 cm [KK1991 Table 4, Eq. 6]; branching angles 61, 59,
+	// 65 degrees by the lateral's order 2-4 [KK1991 Fig. 2]
+	config.shoot_rules = [1, 2, 3].map(source => make_conifer_shoot_rule(source, 5, {
+		carrier_order: source === 3 ? 2 : 1,
+		mean_unit_length: [0.1102],
+		max_unit_length: [0.475],
+		insertion_angle: [1.065, 1.030, 1.134]
+	}));
+	config.shoot_rules.push(make_conifer_leader_rule(5));
+	config.foliage_rules = [0, 1, 2, 3, 5].map(source => FoliageSpawnRule.from({
+		source,
+		phyllotaxis_mode: PhyllotaxisMode.SpiralGolden
+	}));
+}
+
 /**
  * Returns a rich, botanically tuned `TreeSpeciesConfig` for one of the 9 built-in
  * `TreePreset` archetypes (`Oak`, `Pine`, `Birch`, `Willow`, `Maple`, `Spruce`, `Palm`, `Shrub`, `Fern`),
  * with optional deep parameter overrides.
  *
+ * A species is the same for both front ends but where the botanical one grows its framework from shoots: the pine's,
+ * which grows from its seed, has its own framework for the generator graph.
+ *
  * @param {TreePreset|string} [preset=TreePreset.Oak]
  * @param {Object} [overrides]
+ * @param {TreeGrowth} [growth=TreeGrowth.Botanical] which front end the species is grown by
  * @returns {TreeSpeciesConfig}
  */
-export function make_tree_species_preset(preset = TreePreset.Oak, overrides = {}) {
+export function make_tree_species_preset(preset = TreePreset.Oak, overrides = {}, growth = TreeGrowth.Botanical) {
 	const config = new TreeSpeciesConfig();
 	const key = typeof preset === "string" ? preset.toLowerCase() : TreePreset.Oak;
 
@@ -177,8 +327,9 @@ export function make_tree_species_preset(preset = TreePreset.Oak, overrides = {}
 		case TreePreset.Pine: {
 			// Pinus follows Rauh's model (Pfisterer 2000): its branches are orthotropic, built like the trunk, so they carry no
 			// plagiotropism.
-			// Grown from the seed leader: one whorl of branches a year at the leader's tip, and every order below from the
-			// same shoot demography [KK1991]; the generator graph lays only the seed and the roots.
+			// Grown botanically from the seed leader: one whorl of branches a year at the leader's tip, and every order below
+			// from the same shoot demography [KK1991]; the generator graph lays only the seed and the roots. Grown by the
+			// generator graph alone, it stands on a framework of its own (make_pine_framework).
 			config.name = "pine";
 			config.preset = TreePreset.Pine;
 			config.crown.applyOverrides({
@@ -335,6 +486,9 @@ export function make_tree_species_preset(preset = TreePreset.Oak, overrides = {}
 				anthocyanin_potential: 0.0,
 				tannin_oxidation: 0.30
 			});
+			if (growth === TreeGrowth.Graph) {
+				make_pine_framework(config);
+			}
 			break;
 		}
 

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

@@ -132,6 +132,25 @@ export class TreeSkeleton {
      * @type {Float32Array}
      */
     branch_phase_hash: Float32Array;
+    /**
+     * The shoot-prototype instance each branch belongs to (`tree_shoot_instances`), or -1. A prototype draws its leaves,
+     * and its wood where the tree does not draw it as wood: its cuts at the tree's error, placed on the tree. The tree's
+     * own leaves (`foliage_collect_attachments`) leave it out.
+     * @type {Int32Array}
+     */
+    branch_instance: Int32Array;
+    /**
+     * One-sided leaf area (m^2) each segment carries that the skeleton does not hold: shoot systems a prototype instance
+     * draws, hanging from it. The wind's mechanics load the segment with it (`tree_skeleton_compute_segment_mechanics`).
+     * @type {Float32Array}
+     */
+    segment_carried_leaf_area: Float32Array;
+    /**
+     * How far (m) what each segment carries without holding it reaches from where it hangs (see
+     * {@link segment_carried_leaf_area}): a bend of the segment moves it by up to that much more.
+     * @type {Float32Array}
+     */
+    segment_carried_reach: Float32Array;
     /**
      * Annual extension units recorded for each branch grown by them (`tree_skeleton_grow_shoots`): branch `b`'s
      * units start at `unit_start_t[branch_unit_offset[b] + k]` for `k < branch_unit_count[b]`, as `t_norm` along

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

@@ -209,6 +209,28 @@ export class TreeSkeleton {
      */
     branch_phase_hash = new Float32Array(INITIAL_BRANCH_CAPACITY);
 
+    /**
+     * The shoot-prototype instance each branch belongs to (`tree_shoot_instances`), or -1. A prototype draws its leaves,
+     * and its wood where the tree does not draw it as wood: its cuts at the tree's error, placed on the tree. The tree's
+     * own leaves (`foliage_collect_attachments`) leave it out.
+     * @type {Int32Array}
+     */
+    branch_instance = new Int32Array(INITIAL_BRANCH_CAPACITY);
+
+    /**
+     * One-sided leaf area (m^2) each segment carries that the skeleton does not hold: shoot systems a prototype instance
+     * draws, hanging from it. The wind's mechanics load the segment with it (`tree_skeleton_compute_segment_mechanics`).
+     * @type {Float32Array}
+     */
+    segment_carried_leaf_area = new Float32Array(INITIAL_SEGMENT_CAPACITY);
+
+    /**
+     * How far (m) what each segment carries without holding it reaches from where it hangs (see
+     * {@link segment_carried_leaf_area}): a bend of the segment moves it by up to that much more.
+     * @type {Float32Array}
+     */
+    segment_carried_reach = new Float32Array(INITIAL_SEGMENT_CAPACITY);
+
     /**
      * Annual extension units recorded for each branch grown by them (`tree_skeleton_grow_shoots`): branch `b`'s
      * units start at `unit_start_t[branch_unit_offset[b] + k]` for `k < branch_unit_count[b]`, as `t_norm` along
@@ -436,6 +458,12 @@ export class TreeSkeleton {
         grow_attribute_capacity(this.attr_segment_hermite_m0, next_cap);
         grow_attribute_capacity(this.attr_segment_hermite_m1, next_cap);
         grow_attribute_capacity(this.attr_segment_metrics, next_cap);
+        const carried = new Float32Array(next_cap);
+        carried.set(this.segment_carried_leaf_area);
+        this.segment_carried_leaf_area = carried;
+        const reach = new Float32Array(next_cap);
+        reach.set(this.segment_carried_reach);
+        this.segment_carried_reach = reach;
         this.#segment_capacity = next_cap;
     }
 
@@ -483,6 +511,7 @@ export class TreeSkeleton {
         this.branch_length = grow_f32(this.branch_length);
         this.branch_base_radius = grow_f32(this.branch_base_radius);
         this.branch_phase_hash = grow_f32(this.branch_phase_hash);
+        this.branch_instance = grow_i32(this.branch_instance);
         const grown_offset = new Uint32Array(next_cap);
         grown_offset.set(this.branch_unit_offset);
         this.branch_unit_offset = grown_offset;
@@ -531,6 +560,7 @@ export class TreeSkeleton {
         this.branch_base_radius[id] = base_radius;
         this.branch_phase_hash[id] = phase_hash;
         this.branch_unit_count[id] = 0;
+        this.branch_instance[id] = -1;
 
         return id;
     }
@@ -678,6 +708,8 @@ export class TreeSkeleton {
         const metrics = /** @type {Float32Array} */ (this.attr_segment_metrics.data);
         metrics[e * 2] = length;
         metrics[e * 2 + 1] = parent_attach_t;
+        this.segment_carried_leaf_area[e] = 0;
+        this.segment_carried_reach[e] = 0;
 
         // Record incoming Hermite segment on v1 if v1 belongs to the same branch or has no segment yet
         const b_info = /** @type {Int32Array} */ (this.attr_node_branch_info.data);
@@ -1239,6 +1271,14 @@ export class TreeSkeleton {
         this.attr_segment_hermite_m1.copy(other.attr_segment_hermite_m1);
         this.attr_segment_metrics.copy(other.attr_segment_metrics);
         this.#segment_capacity = this.attr_segment_endpoints.data.length / 2;
+        if (this.segment_carried_leaf_area.length < this.#segment_capacity) {
+            this.segment_carried_leaf_area = new Float32Array(this.#segment_capacity);
+        }
+        this.segment_carried_leaf_area.set(other.segment_carried_leaf_area.subarray(0, other.segment_count));
+        if (this.segment_carried_reach.length < this.#segment_capacity) {
+            this.segment_carried_reach = new Float32Array(this.#segment_capacity);
+        }
+        this.segment_carried_reach.set(other.segment_carried_reach.subarray(0, other.segment_count));
 
         for (let i = 0; i < other.branch_count; i++) {
             this.branch_root_vertex[i] = other.branch_root_vertex[i];
@@ -1254,6 +1294,7 @@ export class TreeSkeleton {
             this.branch_phase_hash[i] = other.branch_phase_hash[i];
             this.branch_unit_offset[i] = other.branch_unit_offset[i];
             this.branch_unit_count[i] = other.branch_unit_count[i];
+            this.branch_instance[i] = other.branch_instance[i];
         }
 
         this.crown_center.set(other.crown_center);

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

@@ -2,6 +2,7 @@
  * @typedef {Object} TreeSegmentMechanics
  * @property {Float64Array} mid segment midpoints, `3` per segment
  * @property {Float64Array} mass kg per segment (green wood + fresh leaves)
+ * @property {Float64Array} leaf_area one-sided leaf area each segment holds or carries (m^2)
  * @property {Float64Array} flex `integral dx / r^4` per segment (`0` in the soil)
  * @property {Float64Array} moment drag moment carried by each segment per unit `0.5 rho v^2` (m^3)
  * @property {Float64Array} mass_moment moment of the mass carried by each segment (kg m)
@@ -91,6 +92,10 @@ export type TreeSegmentMechanics = {
      * kg per segment (green wood + fresh leaves)
      */
     mass: Float64Array;
+    /**
+     * one-sided leaf area each segment holds or carries (m^2)
+     */
+    leaf_area: Float64Array;
     /**
      * `integral dx / r^4` per segment (`0` in the soil)
      */

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

@@ -1 +1 @@
-{"version":3,"file":"tree_skeleton_compute_joint_mechanics.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/skeleton/tree_skeleton_compute_joint_mechanics.js"],"names":[],"mappings":"AAsEA;;;;;;;;;GASG;AAEH;;;;;;;;;;;GAWG;AACH,kEAJW,OAAO,mBAAmB,EAAE,YAAY,WACxC,OAAO,gCAAgC,EAAE,iBAAiB,GACxD,oBAAoB,CAgJhC;AAED;;;;;;;GAOG;AACH,kEAJW,OAAO,gCAAgC,EAAE,iBAAiB,YAC1D,oBAAoB,OACpB,YAAY,QAQtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,gEARW,OAAO,mBAAmB,EAAE,YAAY,WACxC,OAAO,gCAAgC,EAAE,iBAAiB,YAC1D,oBAAoB,oBACpB,UAAU,cACV,UAAU,kBACV,YAAY,yBACZ,YAAY,QAgCtB;AAED;;;;;;;;;;;;;GAaG;AACH,iEALW,OAAO,mBAAmB,EAAE,YAAY,WACxC,OAAO,gCAAgC,EAAE,iBAAiB,YAC1D,oBAAoB,OACpB,YAAY,QA0CtB;AAED;;;;;;;;GAQG;AACH,kEALW,OAAO,mBAAmB,EAAE,YAAY,WACxC,OAAO,gCAAgC,EAAE,iBAAiB,YAC1D,oBAAoB,OACpB,YAAY,QAYtB;;;;;SA1Ta,YAAY;;;;UACZ,YAAY;;;;UACZ,YAAY;;;;YACZ,YAAY;;;;iBACZ,YAAY;;;;;WACZ,YAAY"}
+{"version":3,"file":"tree_skeleton_compute_joint_mechanics.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/skeleton/tree_skeleton_compute_joint_mechanics.js"],"names":[],"mappings":"AAsEA;;;;;;;;;;GAUG;AAEH;;;;;;;;;;;GAWG;AACH,kEAJW,OAAO,mBAAmB,EAAE,YAAY,WACxC,OAAO,gCAAgC,EAAE,iBAAiB,GACxD,oBAAoB,CAsJhC;AAED;;;;;;;GAOG;AACH,kEAJW,OAAO,gCAAgC,EAAE,iBAAiB,YAC1D,oBAAoB,OACpB,YAAY,QAQtB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,gEARW,OAAO,mBAAmB,EAAE,YAAY,WACxC,OAAO,gCAAgC,EAAE,iBAAiB,YAC1D,oBAAoB,oBACpB,UAAU,cACV,UAAU,kBACV,YAAY,yBACZ,YAAY,QAgCtB;AAED;;;;;;;;;;;;;GAaG;AACH,iEALW,OAAO,mBAAmB,EAAE,YAAY,WACxC,OAAO,gCAAgC,EAAE,iBAAiB,YAC1D,oBAAoB,OACpB,YAAY,QA0CtB;AAED;;;;;;;;GAQG;AACH,kEALW,OAAO,mBAAmB,EAAE,YAAY,WACxC,OAAO,gCAAgC,EAAE,iBAAiB,YAC1D,oBAAoB,OACpB,YAAY,QAYtB;;;;;SAjUa,YAAY;;;;UACZ,YAAY;;;;eACZ,YAAY;;;;UACZ,YAAY;;;;YACZ,YAAY;;;;iBACZ,YAAY;;;;;WACZ,YAAY"}

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

@@ -72,6 +72,7 @@ function segment_flexibility(len, r0, r1) {
  * @typedef {Object} TreeSegmentMechanics
  * @property {Float64Array} mid segment midpoints, `3` per segment
  * @property {Float64Array} mass kg per segment (green wood + fresh leaves)
+ * @property {Float64Array} leaf_area one-sided leaf area each segment holds or carries (m^2)
  * @property {Float64Array} flex `integral dx / r^4` per segment (`0` in the soil)
  * @property {Float64Array} moment drag moment carried by each segment per unit `0.5 rho v^2` (m^3)
  * @property {Float64Array} mass_moment moment of the mass carried by each segment (kg m)
@@ -99,6 +100,7 @@ export function tree_skeleton_compute_segment_mechanics(skeleton, species) {
     const mid = new Float64Array(segment_count * 3);
     const drag_area = new Float64Array(segment_count);
     const mass = new Float64Array(segment_count);
+    const leaf_areas = new Float64Array(segment_count);
     const flex = new Float64Array(segment_count);
     const moment = new Float64Array(segment_count);
     const mass_moment = new Float64Array(segment_count);
@@ -185,6 +187,11 @@ export function tree_skeleton_compute_segment_mechanics(skeleton, species) {
             leaf_area += foliage_leaf_area_per_metre(reach, rule.insertion_angle) * len * overlap / Math.max(1e-6, t1 - t0);
         }
 
+        // and the shoot systems a prototype draws hanging from it, which the skeleton does not hold
+        leaf_area += skeleton.segment_carried_leaf_area[s];
+        card_reach[s] = Math.max(card_reach[s], skeleton.segment_carried_reach[s]);
+
+        leaf_areas[s] = leaf_area;
         drag_area[s] = DRAG_COEFFICIENT_WOOD * 2.0 * r_mean * len + DRAG_COEFFICIENT_FOLIAGE * leaf_area;
         mass[s] = WOOD_DENSITY * Math.PI * r_mean * r_mean * len + LEAF_AREAL_MASS * leaf_area;
         flex[s] = segment_flexibility(len, r0, r1);
@@ -232,7 +239,7 @@ export function tree_skeleton_compute_segment_mechanics(skeleton, species) {
         }
     }
 
-    return { mid, mass, flex, moment, mass_moment, reach };
+    return { mid, mass, leaf_area: leaf_areas, flex, moment, mass_moment, reach };
 }
 
 /**

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

@@ -0,0 +1,70 @@
+/**
+ * @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: import("./TreeSkeleton.js").TreeSkeleton, b: number, out: import("./TreeSkeleton.js").TreeSkeleton, parent: number, parent_edge: number, attach_t: number, hang: number, level: number, placement: TreeBranchPlacement | null, edge_of: Map<number, number>): number;
+/**
+ * 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: import("./TreeSkeleton.js").TreeSkeleton, branches: ArrayLike<number>, out: import("./TreeSkeleton.js").TreeSkeleton): Int32Array;
+/**
+ * `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: Float64Array | number[], m: ArrayLike<number>): void;
+/**
+ * `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: Float64Array | number[], placement: TreeBranchPlacement): void;
+/**
+ * where a copied branch goes, when not where it was: `p' = to + scale turn (p - from)`
+ */
+export type TreeBranchPlacement = {
+    /**
+     * row-major 3x3 rotation, turning its spine, frames, tangents and scars
+     */
+    turn: ArrayLike<number>;
+    /**
+     * uniform: positions about `from`, arc and segment lengths, and girth
+     */
+    scale: number;
+    /**
+     * the point placed at `to`
+     */
+    from: ArrayLike<number>;
+    to: ArrayLike<number>;
+};
+//# sourceMappingURL=tree_skeleton_copy_branches.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tree_skeleton_copy_branches.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/skeleton/tree_skeleton_copy_branches.js"],"names":[],"mappings":"AAOA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH,kDAZW,OAAO,mBAAmB,EAAE,YAAY,KACxC,MAAM,OACN,OAAO,mBAAmB,EAAE,YAAY,UACxC,MAAM,eACN,MAAM,YACN,MAAM,QACN,MAAM,SACN,MAAM,aACN,mBAAmB,GAAC,IAAI,WACxB,IAAI,MAAM,EAAE,MAAM,CAAC,GACjB,MAAM,CAmElB;AAED;;;;;;;;;;;GAWG;AACH,oDALW,OAAO,mBAAmB,EAAE,YAAY,YACxC,UAAU,MAAM,CAAC,OACjB,OAAO,mBAAmB,EAAE,YAAY,GACtC,UAAU,CAgCtB;AAED;;;;GAIG;AACH,oCAHW,YAAY,GAAC,MAAM,EAAE,KACrB,UAAU,MAAM,CAAC,QAO3B;AAED;;;;GAIG;AACH,+CAHW,YAAY,GAAC,MAAM,EAAE,aACrB,mBAAmB,QAW7B;;;;;;;;UAjKa,UAAU,MAAM,CAAC;;;;WACjB,MAAM;;;;UACN,UAAU,MAAM,CAAC;QACjB,UAAU,MAAM,CAAC"}