@woosh/meep-engine 3.52.0 → 3.53.0

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

@@ -0,0 +1,1104 @@
+import { PointHashGrid3 } from "../../../core/geom/3d/hash-grid/PointHashGrid3.js";
+import { GOLDEN_RATIO } from "../../../core/math/GOLDEN_RATIO.js";
+import { PI2 } from "../../../core/math/PI2.js";
+import { clamp } from "../../../core/math/clamp.js";
+import { lerp } from "../../../core/math/lerp.js";
+import { curl_noise_3d } from "../../../core/math/noise/curl_noise_3d.js";
+import { seededRandom } from "../../../core/math/random/seededRandom.js";
+import { CrownEnvelopeType } from "../config/CrownEnvelopeType.js";
+import { PhyllotaxisMode } from "../config/PhyllotaxisMode.js";
+import { TreeSpeciesConfig } from "../config/TreeSpeciesConfig.js";
+import { TreeSkeleton } from "./TreeSkeleton.js";
+import { crown_envelope_evaluate, crown_envelope_sdf } from "./crown_envelope_evaluate.js";
+import { spine_frame_double_reflection } from "./spine_frame_double_reflection.js";
+import { tree_skeleton_compute_pipe_radii } from "./tree_skeleton_compute_pipe_radii.js";
+
+const GOLDEN_ANGLE = PI2 / (GOLDEN_RATIO * GOLDEN_RATIO); // ~2.399963229728653 rad (137.50776 deg)
+
+const SCRATCH_CURL = [0, 0, 0];
+const SCRATCH_RMF = new Float64Array(6);
+const SCRATCH_POS = new Float32Array(3);
+const SCRATCH_TAN = new Float32Array(3);
+const SCRATCH_P0 = new Float32Array(3);
+const SCRATCH_T0 = new Float32Array(3);
+const SCRATCH_R0 = new Float32Array(3);
+const SCRATCH_M_PREV = new Float32Array(3);
+const SCRATCH_M_NEXT = new Float32Array(3);
+const SCRATCH_GUIDE_P0 = new Float32Array(3);
+const SCRATCH_GUIDE_P1 = new Float32Array(3);
+const SCRATCH_GUIDE_T = new Float32Array(3);
+
+/**
+ * Evaluates the trunk guide curve position `out_pos` and unit tangent `out_tan` at normalized
+ * parameter `t_norm` in [0, 1]. Defaults to the vertical upward plumb line `(0, t_norm * trunk_len, 0)`
+ * when `trunk_guide` is null or omitted.
+ *
+ * @param {Float32Array|number[]} out_pos
+ * @param {Float32Array|number[]} out_tan
+ * @param {Array<ArrayLike<number>>|Function|null|undefined} trunk_guide
+ * @param {number} t_norm
+ * @param {number} trunk_len
+ */
+function evaluate_trunk_guide(out_pos, out_tan, trunk_guide, t_norm, trunk_len) {
+    const t = clamp(t_norm, 0.0, 1.0);
+    if (!trunk_guide) {
+        out_pos[0] = 0.0;
+        out_pos[1] = t * trunk_len;
+        out_pos[2] = 0.0;
+        out_tan[0] = 0.0;
+        out_tan[1] = 1.0;
+        out_tan[2] = 0.0;
+        return;
+    }
+
+    const sample_pt = (u, dst) => {
+        if (typeof trunk_guide === "function") {
+            trunk_guide(u, dst);
+            return;
+        }
+        if (Array.isArray(trunk_guide) && trunk_guide.length >= 2) {
+            const n = trunk_guide.length - 1;
+            const su = clamp(u, 0.0, 1.0) * n;
+            const idx = Math.min(n - 1, Math.floor(su));
+            const frac = su - idx;
+            const a = trunk_guide[idx];
+            const b = trunk_guide[idx + 1];
+            dst[0] = lerp(a[0] ?? 0.0, b[0] ?? 0.0, frac);
+            dst[1] = lerp(a[1] ?? 0.0, b[1] ?? 0.0, frac);
+            dst[2] = lerp(a[2] ?? 0.0, b[2] ?? 0.0, frac);
+            return;
+        }
+        dst[0] = 0.0;
+        dst[1] = u * trunk_len;
+        dst[2] = 0.0;
+    };
+
+    sample_pt(t, out_pos);
+    const eps = 0.01;
+    const t_a = Math.max(0.0, t - eps);
+    const t_b = Math.min(1.0, t + eps);
+    const pa = [0, 0, 0];
+    const pb = [0, 0, 0];
+    sample_pt(t_a, pa);
+    sample_pt(t_b, pb);
+    let tx = pb[0] - pa[0];
+    let ty = pb[1] - pa[1];
+    let tz = pb[2] - pa[2];
+    const tl = Math.hypot(tx, ty, tz);
+    if (tl > 1e-8) {
+        out_tan[0] = tx / tl;
+        out_tan[1] = ty / tl;
+        out_tan[2] = tz / tl;
+    } else {
+        out_tan[0] = 0.0;
+        out_tan[1] = 1.0;
+        out_tan[2] = 0.0;
+    }
+}
+
+/**
+ * Rotates unit vector `(vx, vy, vz)` around unit axis `(ax, ay, az)` by `angle` radians (Rodrigues' formula).
+ * @param {number[]|Float64Array} out
+ * @param {number} vx
+ * @param {number} vy
+ * @param {number} vz
+ * @param {number} ax
+ * @param {number} ay
+ * @param {number} az
+ * @param {number} angle
+ */
+function rotate_around_axis(out, vx, vy, vz, ax, ay, az, angle) {
+    const c = Math.cos(angle);
+    const s = Math.sin(angle);
+    const dot = vx * ax + vy * ay + vz * az;
+    const omc = 1.0 - c;
+
+    const cx = ay * vz - az * vy;
+    const cy = az * vx - ax * vz;
+    const cz = ax * vy - ay * vx;
+
+    let rx = vx * c + cx * s + ax * dot * omc;
+    let ry = vy * c + cy * s + ay * dot * omc;
+    let rz = vz * c + cz * s + az * dot * omc;
+
+    const len = Math.sqrt(rx * rx + ry * ry + rz * rz);
+    if (len > 1e-12) {
+        const inv = 1.0 / len;
+        rx *= inv;
+        ry *= inv;
+        rz *= inv;
+    }
+    out[0] = rx;
+    out[1] = ry;
+    out[2] = rz;
+}
+
+/**
+ * Generates a directed botanical `TreeSkeleton` from a `TreeSpeciesConfig`, combining:
+ * - Multi-level parametric Cubic Hermite spine generation (`BranchLevelConfig`, `AnimationCurve` profiles)
+ * - Botanical phyllotaxis (`SpiralGolden`, `AlternateDistichous`, `Tristichous`, `Opposite`, `OppositeDecussate`, `Whorled`)
+ * - 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`)
+ *
+ * @param {TreeSpeciesConfig|Object} [config]
+ * @param {TreeSkeleton} [out]
+ * @returns {TreeSkeleton}
+ */
+export function tree_skeleton_grow(config = new TreeSpeciesConfig(), out = new TreeSkeleton()) {
+    const species = config && config.isTreeSpeciesConfig ? config : TreeSpeciesConfig.from(config);
+    out.clear();
+
+    const rng = seededRandom(species.seed | 0);
+    // Seed-derived 3D noise offset so unseeded Simplex/Curl fields are unique and deterministic per seed
+    const noise_ox = (rng() - 0.5) * 1000.0;
+    const noise_oy = (rng() - 0.5) * 1000.0;
+    const noise_oz = (rng() - 0.5) * 1000.0;
+
+    const crown = species.crown;
+    const crown_cy = crown.base_height + crown.height * 0.5;
+    out.crown_center[0] = 0.0;
+    out.crown_center[1] = crown_cy;
+    out.crown_center[2] = 0.0;
+
+    out.crown_radii[0] = Math.max(0.25, crown.radius);
+    out.crown_radii[1] = Math.max(0.25, crown.height * 0.5);
+    out.crown_radii[2] = Math.max(0.25, crown.radius);
+
+    // Build Space Colonization attraction point cloud + PointHashGrid3 once
+    const use_space_col = crown.space_colonization_weight > 0.0 && crown.attraction_point_count > 0;
+    const attr_count = use_space_col ? (crown.attraction_point_count | 0) : 0;
+    const attr_positions = new Float32Array(attr_count * 3);
+    const attr_alive = new Uint8Array(attr_count);
+    let attr_grid = null;
+
+    if (use_space_col) {
+        let placed = 0;
+        let attempts = 0;
+        const max_attempts = attr_count * 12;
+        while (placed < attr_count && attempts < max_attempts) {
+            attempts++;
+            const u_h = rng();
+            const env_r = crown.radius * crown_envelope_evaluate(crown.envelope_type, u_h);
+            const rx = (rng() * 2.0 - 1.0) * env_r;
+            const rz = (rng() * 2.0 - 1.0) * env_r;
+            if (rx * rx + rz * rz <= env_r * env_r) {
+                const ry = crown.base_height + u_h * crown.height;
+                attr_positions[placed * 3] = rx;
+                attr_positions[placed * 3 + 1] = ry;
+                attr_positions[placed * 3 + 2] = rz;
+                attr_alive[placed] = 1;
+                placed++;
+            }
+        }
+        while (placed < attr_count) {
+            const theta = rng() * PI2;
+            const u_h = rng();
+            const r = Math.sqrt(rng()) * crown.radius * crown_envelope_evaluate(crown.envelope_type, u_h);
+            attr_positions[placed * 3] = Math.cos(theta) * r;
+            attr_positions[placed * 3 + 1] = crown.base_height + u_h * crown.height;
+            attr_positions[placed * 3 + 2] = Math.sin(theta) * r;
+            attr_alive[placed] = 1;
+            placed++;
+        }
+
+        attr_grid = new PointHashGrid3();
+        attr_grid.build(attr_positions, attr_count, Math.max(0.25, crown.attraction_radius));
+    }
+
+    const r_influence_sq = crown.attraction_radius * crown.attraction_radius;
+    const r_kill_sq = crown.kill_radius * crown.kill_radius;
+
+    // Queue of branches to grow in level-order (guarantees parent branches & vertices precede children)
+    const queue = [];
+
+    const lvl0 = species.levels[0];
+    if (!lvl0) {
+        return out;
+    }
+
+    const trunk_len = Math.max(0.2, lvl0.length * (1.0 + (rng() * 2.0 - 1.0) * lvl0.length_variance));
+    const trunk_base_r = Math.max(0.01, trunk_len * lvl0.radius_ratio);
+
+    evaluate_trunk_guide(SCRATCH_GUIDE_P0, SCRATCH_GUIDE_T, species.trunk_guide, 0.0, trunk_len);
+
+    // Apply subtle initial basal trunk lean around the guide tangent
+    const max_lean = lvl0.phyllotaxis_mode === PhyllotaxisMode.Whorled ? 0.025 : 0.06;
+    const lean_ang = clamp((lvl0.basal_lean ?? 0.02) * (0.75 + 0.5 * rng()), 0.0, max_lean);
+    const lean_az = rng() * PI2;
+    const init_tx = clamp(SCRATCH_GUIDE_T[0] + Math.sin(lean_ang) * Math.cos(lean_az), -0.95, 0.95);
+    const init_ty = Math.max(0.2, SCRATCH_GUIDE_T[1] * Math.cos(lean_ang));
+    const init_tz = clamp(SCRATCH_GUIDE_T[2] + Math.sin(lean_ang) * Math.sin(lean_az), -0.95, 0.95);
+    const init_t_len = Math.hypot(init_tx, init_ty, init_tz) || 1.0;
+    const norm_tx = init_tx / init_t_len;
+    const norm_ty = init_ty / init_t_len;
+    const norm_tz = init_tz / init_t_len;
+
+    // Orthonormal initial R perpendicular to norm_T
+    let init_rx = 1.0 - norm_tx * norm_tx;
+    let init_ry = -norm_ty * norm_tx;
+    let init_rz = -norm_tz * norm_tx;
+    const init_r_len = Math.hypot(init_rx, init_ry, init_rz) || 1.0;
+    init_rx /= init_r_len;
+    init_ry /= init_r_len;
+    init_rz /= init_r_len;
+
+    queue.push({
+        level: 0,
+        parent_branch_id: -1,
+        parent_edge_id: -1,
+        parent_attach_t: 0.0,
+        start_vertex: -1,
+        px: SCRATCH_GUIDE_P0[0],
+        py: SCRATCH_GUIDE_P0[1],
+        pz: SCRATCH_GUIDE_P0[2],
+        tx: norm_tx,
+        ty: norm_ty,
+        tz: norm_tz,
+        rx: init_rx,
+        ry: init_ry,
+        rz: init_rz,
+        length: trunk_len,
+        base_radius: trunk_base_r,
+        start_seg: 0,
+        total_segs: Math.max(1, lvl0.segments),
+        initial_arc_s: 0.0,
+        has_split: false
+    });
+
+    const rot_scratch = [0, 0, 0];
+
+    for (let q_idx = 0; q_idx < queue.length; q_idx++) {
+        const job = queue[q_idx];
+        const level = job.level;
+        const lvl_cfg = species.levels[level];
+        if (!lvl_cfg) continue;
+
+        const phase_hash = rng();
+        const N_seg = job.total_segs;
+        const remaining_segs = N_seg - job.start_seg;
+        if (remaining_segs <= 0) continue;
+
+        const step_len = job.length / N_seg;
+
+        let cur_px = job.px;
+        let cur_py = job.py;
+        let cur_pz = job.pz;
+        let cur_tx = job.tx;
+        let cur_ty = job.ty;
+        let cur_tz = job.tz;
+        let cur_rx = job.rx;
+        let cur_ry = job.ry;
+        let cur_rz = job.rz;
+        let cur_arc_s = job.initial_arc_s;
+
+        // Compute binormal S = T x R
+        let cur_sx = cur_ty * cur_rz - cur_tz * cur_ry;
+        let cur_sy = cur_tz * cur_rx - cur_tx * cur_rz;
+        let cur_sz = cur_tx * cur_ry - cur_ty * cur_rx;
+
+        let prev_v = job.start_vertex;
+        let branch_id = -1;
+
+        if (prev_v < 0) {
+            const t0 = job.start_seg / N_seg;
+            const r0_profile = Math.max(0.05, lvl_cfg.radius_profile.evaluate(t0));
+            const r0 = Math.max(0.002, job.base_radius * Math.max(1.0 - lvl_cfg.taper * t0, 0.05) * r0_profile);
+
+            branch_id = out.add_branch(
+                0,
+                level,
+                job.parent_branch_id,
+                job.parent_edge_id,
+                job.parent_attach_t,
+                job.length,
+                r0,
+                phase_hash
+            );
+            prev_v = out.add_node(
+                cur_px, cur_py, cur_pz,
+                cur_tx, cur_ty, cur_tz,
+                cur_rx, cur_ry, cur_rz,
+                r0,
+                branch_id,
+                level,
+                job.parent_branch_id,
+                t0,
+                cur_arc_s,
+                phase_hash
+            );
+            if (job.attach_parent_vertex !== undefined && job.attach_parent_vertex >= 0) {
+                out.connect_nodes(job.attach_parent_vertex, prev_v);
+            }
+            out.branch_root_vertex[branch_id] = prev_v;
+            out.branch_tip_vertex[branch_id] = prev_v;
+        } else {
+            const prev_r = out.node_read_radius(prev_v);
+            branch_id = out.add_branch(
+                prev_v,
+                level,
+                job.parent_branch_id,
+                job.parent_edge_id,
+                job.parent_attach_t,
+                job.length,
+                prev_r,
+                phase_hash
+            );
+        }
+
+        const branch_edges = [];
+        const branch_edge_t0 = [];
+        const branch_edge_t1 = [];
+        const branch_vertices = [prev_v];
+
+        // Pre-schedule phyllotactic child attachment parameters so the parent spine kinks sympodially at lateral emissions
+        const next_level_preview = level + 1;
+        const has_children = next_level_preview < species.levels.length && lvl_cfg.child_count > 0;
+        const span_fraction_est = job.child_span_fraction ?? Math.max(0.25, (N_seg - job.start_seg) / Math.max(1, N_seg));
+        const planned_child_count = has_children
+            ? (span_fraction_est < 0.99 ? Math.max(1, Math.round(lvl_cfg.child_count * span_fraction_est)) : lvl_cfg.child_count)
+            : 0;
+        const bare_est = clamp(lvl_cfg.bare_length_ratio, 0.0, 0.92);
+        const t_min_est = Math.max(bare_est, job.start_seg / N_seg);
+        const base_phi = rng() * PI2;
+        const scheduled_children = [];
+
+        if (planned_child_count > 0 && 1.0 > t_min_est + 1e-3) {
+            for (let c = 0; c < planned_child_count; c++) {
+                let u_c = (c + 0.5) / planned_child_count;
+                if (lvl_cfg.phyllotaxis_mode === PhyllotaxisMode.Opposite
+                    || lvl_cfg.phyllotaxis_mode === PhyllotaxisMode.OppositeDecussate) {
+                    const pair_idx = c >> 1;
+                    const pair_count = Math.max(1, Math.ceil(planned_child_count / 2));
+                    u_c = (pair_idx + 0.5) / pair_count;
+                } else if (lvl_cfg.phyllotaxis_mode === PhyllotaxisMode.Whorled) {
+                    const w_size = Math.max(1, lvl_cfg.whorl_count | 0);
+                    const whorl_idx = Math.floor(c / w_size);
+                    const whorl_total = Math.max(1, Math.ceil(planned_child_count / w_size));
+                    u_c = (whorl_idx + 0.5) / whorl_total;
+                }
+
+                const t_att = clamp(
+                    lerp(t_min_est, 0.96, u_c) + (rng() - 0.5) * (0.3 / planned_child_count),
+                    t_min_est,
+                    0.98
+                );
+
+                let phi_c = base_phi;
+                switch (lvl_cfg.phyllotaxis_mode) {
+                    case PhyllotaxisMode.AlternateDistichous:
+                        phi_c += c * Math.PI;
+                        break;
+                    case PhyllotaxisMode.Tristichous:
+                        phi_c += c * (PI2 / 3.0);
+                        break;
+                    case PhyllotaxisMode.Opposite:
+                        phi_c += (c & 1) * Math.PI;
+                        break;
+                    case PhyllotaxisMode.OppositeDecussate:
+                        phi_c += (c & 1) * Math.PI + (c >> 1) * (Math.PI * 0.5);
+                        break;
+                    case PhyllotaxisMode.Whorled: {
+                        const w_size = Math.max(1, lvl_cfg.whorl_count | 0);
+                        const w_idx = Math.floor(c / w_size);
+                        const sub_idx = c % w_size;
+                        phi_c += (sub_idx * PI2) / w_size + (w_idx * Math.PI) / w_size;
+                        break;
+                    }
+                    case PhyllotaxisMode.SpiralGolden:
+                    default:
+                        phi_c += c * GOLDEN_ANGLE;
+                        break;
+                }
+                phi_c += (rng() * 2.0 - 1.0) * lvl_cfg.azimuth_jitter;
+                scheduled_children.push({ t_attach: t_att, phi: phi_c });
+            }
+        }
+
+        const k_symp = lvl_cfg.nodal_kink_strength ?? 0.45;
+        const zig_base = lvl_cfg.internode_zigzag ?? 0.06;
+        const tip_up = lvl_cfg.tip_upcurl ?? 0.18;
+
+        for (let s = job.start_seg + 1; s <= N_seg; s++) {
+            const t_prev = (s - 1) / N_seg;
+            const t_curr = s / N_seg;
+
+            // 1. Intrinsic S-curve pitch curvature (zero-mean higher harmonic on trunk so trunk weaves rather than leaning)
+            const s_wave = level === 0
+                ? (lvl_cfg.curvature * Math.sin(PI2 * 1.5 * t_curr + phase_hash * PI2))
+                : (lvl_cfg.curve_back !== 0.0
+                    ? (lvl_cfg.curvature * Math.cos(Math.PI * t_curr) + lvl_cfg.curve_back * Math.sin(PI2 * t_curr))
+                    : lvl_cfg.curvature);
+            const d_pitch = s_wave / Math.max(2, N_seg * 0.65);
+
+            if (Math.abs(d_pitch) > 1e-6) {
+                rotate_around_axis(rot_scratch, cur_tx, cur_ty, cur_tz, cur_sx, cur_sy, cur_sz, d_pitch);
+                cur_tx = rot_scratch[0];
+                cur_ty = rot_scratch[1];
+                cur_tz = rot_scratch[2];
+                rotate_around_axis(rot_scratch, cur_rx, cur_ry, cur_rz, cur_sx, cur_sy, cur_sz, d_pitch);
+                cur_rx = rot_scratch[0];
+                cur_ry = rot_scratch[1];
+                cur_rz = rot_scratch[2];
+            }
+
+            // 2. Helical spiral twist around T
+            if (Math.abs(lvl_cfg.spiral_twist) > 1e-6) {
+                const d_twist = lvl_cfg.spiral_twist / N_seg;
+                rotate_around_axis(rot_scratch, cur_rx, cur_ry, cur_rz, cur_tx, cur_ty, cur_tz, d_twist);
+                cur_rx = rot_scratch[0];
+                cur_ry = rot_scratch[1];
+                cur_rz = rot_scratch[2];
+                cur_sx = cur_ty * cur_rz - cur_tz * cur_ry;
+                cur_sy = cur_tz * cur_rx - cur_tx * cur_rz;
+                cur_sz = cur_tx * cur_ry - cur_ty * cur_rx;
+            }
+
+            // 2b. Sympodial Nodal Kinking at scheduled lateral child emissions + Internodal Zig-Zag
+            let kink_rx = 0.0;
+            let kink_ry = 0.0;
+            let kink_rz = 0.0;
+
+            if (k_symp > 0.0 && scheduled_children.length > 0 && lvl_cfg.phyllotaxis_mode !== PhyllotaxisMode.Whorled) {
+                for (let c = 0; c < scheduled_children.length; c++) {
+                    const sc = scheduled_children[c];
+                    if (sc.t_attach >= t_prev && sc.t_attach <= t_curr) {
+                        // Recoil away from child branch emission azimuth phi
+                        const recoil_phi = sc.phi + Math.PI;
+                        const c_recoil = Math.cos(recoil_phi);
+                        const s_recoil = Math.sin(recoil_phi);
+                        const amp = clamp(0.18 * k_symp * Math.sin(lvl_cfg.insertion_angle), 0.0, 0.32);
+                        kink_rx += (c_recoil * cur_rx + s_recoil * cur_sx) * amp;
+                        kink_ry += (c_recoil * cur_ry + s_recoil * cur_sy) * amp;
+                        kink_rz += (c_recoil * cur_rz + s_recoil * cur_sz) * amp;
+                    }
+                }
+            }
+
+            if (zig_base > 0.0) {
+                // Alternate by PI on trunk so consecutive internode kinks balance around the plumb line
+                const zig_step = (level === 0 || lvl_cfg.phyllotaxis_mode === PhyllotaxisMode.AlternateDistichous)
+                    ? Math.PI
+                    : GOLDEN_ANGLE;
+                const zig_phi = base_phi + s * zig_step + (rng() - 0.5) * 0.55;
+                const zig_amp = zig_base * (0.65 + 0.70 * rng()) * (0.65 + 0.35 * t_curr);
+                const cz = Math.cos(zig_phi);
+                const sz = Math.sin(zig_phi);
+                kink_rx += (cz * cur_rx + sz * cur_sx) * zig_amp;
+                kink_ry += (cz * cur_ry + sz * cur_sy) * zig_amp;
+                kink_rz += (cz * cur_rz + sz * cur_sz) * zig_amp;
+            }
+
+            const kink_mag = Math.hypot(kink_rx, kink_ry, kink_rz);
+            if (kink_mag > 1e-6) {
+                // Rotation axis B = T x (kink_dir) in the (R, S) plane
+                const kx = kink_rx / kink_mag;
+                const ky = kink_ry / kink_mag;
+                const kz = kink_rz / kink_mag;
+                let bx = cur_ty * kz - cur_tz * ky;
+                let by = cur_tz * kx - cur_tx * kz;
+                let bz = cur_tx * ky - cur_ty * kx;
+                const b_len = Math.hypot(bx, by, bz);
+                if (b_len > 1e-6) {
+                    bx /= b_len;
+                    by /= b_len;
+                    bz /= b_len;
+                    const clamped_kink = Math.min(0.42, kink_mag);
+                    rotate_around_axis(rot_scratch, cur_tx, cur_ty, cur_tz, bx, by, bz, clamped_kink);
+                    cur_tx = rot_scratch[0];
+                    cur_ty = rot_scratch[1];
+                    cur_tz = rot_scratch[2];
+                    rotate_around_axis(rot_scratch, cur_rx, cur_ry, cur_rz, bx, by, bz, clamped_kink);
+                    cur_rx = rot_scratch[0];
+                    cur_ry = rot_scratch[1];
+                    cur_rz = rot_scratch[2];
+                    cur_sx = cur_ty * cur_rz - cur_tz * cur_ry;
+                    cur_sy = cur_tz * cur_rx - cur_tx * cur_rz;
+                    cur_sz = cur_tx * cur_ry - cur_ty * cur_rx;
+                }
+            }
+
+            // 3. Biomechanical Tropism steering (Gravitropic sag + Terminal Phototropic Up-Curl + Outward spread)
+            let steer_x = 0.0;
+            let steer_y = 0.0;
+            let steer_z = 0.0;
+
+            if (level === 0) {
+                // Orthotropic upward striving & plumb-line righting reflex along guide curve (default vertical +Y)
+                evaluate_trunk_guide(SCRATCH_GUIDE_P0, SCRATCH_GUIDE_T, species.trunk_guide, t_prev, job.length);
+                evaluate_trunk_guide(SCRATCH_GUIDE_P1, SCRATCH_GUIDE_T, species.trunk_guide, t_curr, job.length);
+                const gtx = SCRATCH_GUIDE_T[0];
+                const gty = SCRATCH_GUIDE_T[1];
+                const gtz = SCRATCH_GUIDE_T[2];
+
+                const righting = 1.65 + Math.max(0.0, -lvl_cfg.gravitropism) * 2.5 + Math.max(0.0, lvl_cfg.phototropism);
+                steer_x += gtx * righting;
+                steer_y += gty * righting;
+                steer_z += gtz * righting;
+
+                // Plumb-line centering force pulling lateral drift back toward the guide curve
+                const dx_g = cur_px - SCRATCH_GUIDE_P0[0];
+                const dy_g = cur_py - SCRATCH_GUIDE_P0[1];
+                const dz_g = cur_pz - SCRATCH_GUIDE_P0[2];
+                const dot_g = dx_g * gtx + dy_g * gty + dz_g * gtz;
+                const lat_x = dx_g - dot_g * gtx;
+                const lat_y = dy_g - dot_g * gty;
+                const lat_z = dz_g - dot_g * gtz;
+                const plumb_k = (lvl_cfg.phyllotaxis_mode === PhyllotaxisMode.Whorled ? 5.2 : 3.4) / Math.max(1.0, job.length);
+                steer_x -= lat_x * plumb_k * N_seg * 0.5;
+                steer_y -= lat_y * plumb_k * N_seg * 0.5;
+                steer_z -= lat_z * plumb_k * N_seg * 0.5;
+            } else {
+                if (lvl_cfg.gravitropism !== 0.0 || tip_up !== 0.0) {
+                    if (crown.envelope_type === CrownEnvelopeType.Weeping && level >= 2) {
+                        steer_y -= lvl_cfg.gravitropism * (0.4 + 1.2 * t_curr);
+                    } else {
+                        // Cantilever sag in mid-span followed by phototropic up-curl near branch tips
+                        const sag_term = lvl_cfg.gravitropism * 3.0 * t_curr * Math.pow(Math.max(0.0, 1.0 - t_curr), 0.75);
+                        const up_term = tip_up * Math.pow(t_curr, 1.5);
+                        steer_y += up_term - sag_term;
+                    }
+                }
+
+                if (lvl_cfg.phototropism !== 0.0) {
+                    const raw_sky_mix = clamp(crown.sky_phototropism_mix ?? 0.6, 0.0, 1.0);
+                    const sky_mix = level === 1 ? raw_sky_mix * 0.45 : raw_sky_mix;
+                    const horiz_r = Math.sqrt(cur_px * cur_px + cur_pz * cur_pz);
+                    const out_x = horiz_r > 1e-4 ? cur_px / horiz_r : cur_rx;
+                    const out_z = horiz_r > 1e-4 ? cur_pz / horiz_r : cur_rz;
+
+                    steer_x += lvl_cfg.phototropism * (1.0 - sky_mix) * out_x;
+                    steer_y += lvl_cfg.phototropism * sky_mix;
+                    steer_z += lvl_cfg.phototropism * (1.0 - sky_mix) * out_z;
+                }
+            }
+
+            // 4. 2-Octave 3D Curl Noise gnarl scaled properly by sqrt(6 / N_seg)
+            if (lvl_cfg.gnarl_strength > 0.0) {
+                const freq = lvl_cfg.gnarl_frequency;
+                curl_noise_3d(
+                    SCRATCH_CURL,
+                    cur_px * freq + noise_ox + level * 17.3,
+                    cur_py * freq + noise_oy + level * 31.7,
+                    cur_pz * freq + noise_oz + level * 47.1
+                );
+                const c1x = SCRATCH_CURL[0], c1y = SCRATCH_CURL[1], c1z = SCRATCH_CURL[2];
+                curl_noise_3d(
+                    SCRATCH_CURL,
+                    cur_px * freq * 2.15 + noise_ox + 53.1 + phase_hash * 29.3,
+                    cur_py * freq * 2.15 + noise_oy + 79.3,
+                    cur_pz * freq * 2.15 + noise_oz + 113.7
+                );
+                const cx_tot = 0.68 * c1x + 0.32 * SCRATCH_CURL[0];
+                const cy_tot = 0.68 * c1y + 0.32 * SCRATCH_CURL[1];
+                const cz_tot = 0.68 * c1z + 0.32 * SCRATCH_CURL[2];
+
+                const gnarl_scale = lvl_cfg.gnarl_strength * Math.sqrt(6.0 / Math.max(2, N_seg));
+                // Project curl vector perpendicular to T so it steers direction cleanly
+                const dot_ct = cx_tot * cur_tx + cy_tot * cur_ty + cz_tot * cur_tz;
+                steer_x += (cx_tot - dot_ct * cur_tx) * gnarl_scale * 2.2;
+                steer_y += (cy_tot - dot_ct * cur_ty) * gnarl_scale * 1.6;
+                steer_z += (cz_tot - dot_ct * cur_tz) * gnarl_scale * 2.2;
+            }
+
+            // 5. Space colonization attraction steering (for branches in crown, level >= 1)
+            if (use_space_col && level >= 1 && attr_grid !== null) {
+                let attr_vx = 0.0;
+                let attr_vy = 0.0;
+                let attr_vz = 0.0;
+                let attr_hits = 0;
+
+                attr_grid.forEachNear(cur_px, cur_py, cur_pz, (idx) => {
+                    if (attr_alive[idx] === 0) return;
+                    const ax = attr_positions[idx * 3] - cur_px;
+                    const ay = attr_positions[idx * 3 + 1] - cur_py;
+                    const az = attr_positions[idx * 3 + 2] - cur_pz;
+                    const d2 = ax * ax + ay * ay + az * az;
+                    if (d2 <= r_kill_sq) {
+                        attr_alive[idx] = 0;
+                    } else if (d2 <= r_influence_sq && d2 > 1e-8) {
+                        const inv_d = 1.0 / Math.sqrt(d2);
+                        attr_vx += ax * inv_d;
+                        attr_vy += ay * inv_d;
+                        attr_vz += az * inv_d;
+                        attr_hits++;
+                    }
+                });
+
+                if (attr_hits > 0) {
+                    const attr_len = Math.sqrt(attr_vx * attr_vx + attr_vy * attr_vy + attr_vz * attr_vz);
+                    if (attr_len > 1e-6) {
+                        const w_sc = crown.space_colonization_weight / attr_len;
+                        steer_x += attr_vx * w_sc;
+                        steer_y += attr_vy * w_sc;
+                        steer_z += attr_vz * w_sc;
+                    }
+                }
+            }
+
+            // 6. Crown envelope soft containment for lateral branches (level >= 1)
+            let seg_len = step_len;
+            if (level >= 1 && crown.prune_ratio > 0.0) {
+                const probe_x = cur_px + cur_tx * step_len;
+                const probe_y = cur_py + cur_ty * step_len;
+                const probe_z = cur_pz + cur_tz * step_len;
+                const sdf = crown_envelope_sdf(probe_x, probe_y, probe_z, crown);
+                if (sdf > 0.0) {
+                    // Gently steer back toward crown center and shorten segment near boundary
+                    const to_cx = -probe_x;
+                    const to_cy = crown_cy - probe_y;
+                    const to_cz = -probe_z;
+                    const to_c_len = Math.sqrt(to_cx * to_cx + to_cy * to_cy + to_cz * to_cz);
+                    if (to_c_len > 1e-5) {
+                        const pull = crown.prune_ratio * 0.45 / to_c_len;
+                        steer_x += to_cx * pull;
+                        steer_y += to_cy * pull;
+                        steer_z += to_cz * pull;
+                    }
+                    seg_len *= Math.max(0.35, 1.0 - crown.prune_ratio * 0.5);
+                }
+            }
+
+            // Apply steering to tangent and normalize
+            const steer_div = Math.max(2.0, Math.sqrt(N_seg) * 1.35);
+            let next_tx = cur_tx + steer_x / steer_div;
+            let next_ty = cur_ty + steer_y / steer_div;
+            let next_tz = cur_tz + steer_z / steer_div;
+            const t_len = Math.sqrt(next_tx * next_tx + next_ty * next_ty + next_tz * next_tz);
+            if (t_len > 1e-12) {
+                next_tx /= t_len;
+                next_ty /= t_len;
+                next_tz /= t_len;
+            } else {
+                next_tx = cur_tx;
+                next_ty = cur_ty;
+                next_tz = cur_tz;
+            }
+
+            let next_px = cur_px + 0.5 * (cur_tx + next_tx) * seg_len;
+            let next_py = cur_py + 0.5 * (cur_ty + next_ty) * seg_len;
+            let next_pz = cur_pz + 0.5 * (cur_tz + next_tz) * seg_len;
+
+            // Orthotropic plumb-tube containment on trunk (level === 0):
+            // Preserves local 3D nodal kinks and serpentine sweep while guaranteeing the trunk never drifts sideways
+            if (level === 0 && branch_id === 0) {
+                const gx = SCRATCH_GUIDE_P1[0];
+                const gy = SCRATCH_GUIDE_P1[1];
+                const gz = SCRATCH_GUIDE_P1[2];
+                const gtx = SCRATCH_GUIDE_T[0];
+                const gty = SCRATCH_GUIDE_T[1];
+                const gtz = SCRATCH_GUIDE_T[2];
+
+                const dx = next_px - gx;
+                const dy = next_py - gy;
+                const dz = next_pz - gz;
+                const dot_g = dx * gtx + dy * gty + dz * gtz;
+                const off_x = dx - dot_g * gtx;
+                const off_y = dy - dot_g * gty;
+                const off_z = dz - dot_g * gtz;
+                const off_r = Math.hypot(off_x, off_y, off_z);
+
+                const is_conifer = lvl_cfg.phyllotaxis_mode === PhyllotaxisMode.Whorled;
+                const max_drift_frac = is_conifer ? 0.032 : 0.058;
+                // Envelope rises from 0 at root, peaks in mid-trunk (allowing 3D sweep/crookedness), and tapers near tip
+                const env = Math.sin(Math.PI * Math.min(0.92, t_curr * 0.88)) * (1.0 - 0.38 * t_curr * t_curr);
+                const max_r = job.length * max_drift_frac * Math.max(0.18, env);
+
+                if (off_r > max_r && off_r > 1e-6) {
+                    const scale_r = max_r / off_r;
+                    next_px = gx + dot_g * gtx + off_x * scale_r;
+                    next_py = gy + dot_g * gty + off_y * scale_r;
+                    next_pz = gz + dot_g * gtz + off_z * scale_r;
+
+                    let ch_x = next_px - cur_px;
+                    let ch_y = next_py - cur_py;
+                    let ch_z = next_pz - cur_pz;
+                    const ch_l = Math.hypot(ch_x, ch_y, ch_z);
+                    if (ch_l > 1e-6) {
+                        next_tx = ch_x / ch_l;
+                        next_ty = ch_y / ch_l;
+                        next_tz = ch_z / ch_l;
+                    }
+                }
+            }
+
+            // Transport RMF via Wang et al. Double Reflection
+            spine_frame_double_reflection(
+                SCRATCH_RMF, 0,
+                cur_px, cur_py, cur_pz,
+                cur_tx, cur_ty, cur_tz,
+                cur_rx, cur_ry, cur_rz,
+                next_px, next_py, next_pz,
+                next_tx, next_ty, next_tz
+            );
+            let next_rx = SCRATCH_RMF[0];
+            let next_ry = SCRATCH_RMF[1];
+            let next_rz = SCRATCH_RMF[2];
+            cur_sx = SCRATCH_RMF[3];
+            cur_sy = SCRATCH_RMF[4];
+            cur_sz = SCRATCH_RMF[5];
+
+            cur_arc_s += seg_len;
+
+            const r_prof = Math.max(0.04, lvl_cfg.radius_profile.evaluate(t_curr));
+            const r_curr = Math.max(
+                0.0015,
+                job.base_radius * Math.max(1.0 - lvl_cfg.taper * t_curr, 0.05) * r_prof
+            );
+
+            const curr_v = out.add_node(
+                next_px, next_py, next_pz,
+                next_tx, next_ty, next_tz,
+                next_rx, next_ry, next_rz,
+                r_curr,
+                branch_id,
+                level,
+                job.parent_branch_id,
+                t_curr,
+                cur_arc_s,
+                phase_hash
+            );
+
+            const edge_id = out.add_segment(
+                prev_v,
+                curr_v,
+                cur_tx * seg_len,
+                cur_ty * seg_len,
+                cur_tz * seg_len,
+                next_tx * seg_len,
+                next_ty * seg_len,
+                next_tz * seg_len,
+                seg_len,
+                t_prev === 0.0 ? job.parent_attach_t : t_prev
+            );
+
+            branch_edges.push(edge_id);
+            branch_edge_t0.push(t_prev);
+            branch_edge_t1.push(t_curr);
+            branch_vertices.push(curr_v);
+
+            out.branch_tip_vertex[branch_id] = curr_v;
+            out.branch_length[branch_id] = cur_arc_s - job.initial_arc_s;
+
+            // Check for dichotomous / sympodial splitting at interior segments
+            const min_split_seg = level === 0
+                ? Math.max(2, Math.floor(N_seg * 0.5))
+                : Math.max(1, Math.floor(N_seg * 0.25));
+            if (
+                !job.has_split
+                && lvl_cfg.split_probability > 0.0
+                && s >= min_split_seg
+                && s <= Math.floor(N_seg * 0.75)
+                && rng() < lvl_cfg.split_probability
+            ) {
+                job.has_split = true;
+                const fork_count = Math.max(2, lvl_cfg.split_count | 0);
+                const split_ang = lvl_cfg.split_angle;
+                const base_az = rng() * PI2;
+
+                // Preserve pre-split orthonormal triad (T, R, S) before deflecting fork 0
+                const pre_tx = next_tx, pre_ty = next_ty, pre_tz = next_tz;
+                const pre_rx = next_rx, pre_ry = next_ry, pre_rz = next_rz;
+                const pre_sx = cur_sx, pre_sy = cur_sy, pre_sz = cur_sz;
+
+                // Current branch deflects as fork 0: rotate both T and R around bend_axis so R remains orthogonal to T
+                const fork0_deflect = level === 0 ? split_ang * 0.22 : split_ang * 0.5;
+                const bend_axis_x = Math.cos(base_az) * pre_rx + Math.sin(base_az) * pre_sx;
+                const bend_axis_y = Math.cos(base_az) * pre_ry + Math.sin(base_az) * pre_sy;
+                const bend_axis_z = Math.cos(base_az) * pre_rz + Math.sin(base_az) * pre_sz;
+                rotate_around_axis(
+                    rot_scratch,
+                    pre_tx, pre_ty, pre_tz,
+                    bend_axis_x, bend_axis_y, bend_axis_z,
+                    fork0_deflect
+                );
+                next_tx = rot_scratch[0];
+                next_ty = rot_scratch[1];
+                next_tz = rot_scratch[2];
+
+                rotate_around_axis(
+                    rot_scratch,
+                    pre_rx, pre_ry, pre_rz,
+                    bend_axis_x, bend_axis_y, bend_axis_z,
+                    fork0_deflect
+                );
+                next_rx = rot_scratch[0];
+                next_ry = rot_scratch[1];
+                next_rz = rot_scratch[2];
+
+                cur_sx = next_ty * next_rz - next_tz * next_ry;
+                cur_sy = next_tz * next_rx - next_tx * next_rz;
+                cur_sz = next_tx * next_ry - next_ty * next_rx;
+
+                // Spawn fork 1..fork_count-1 as continuation branches with their own root vertex connected to curr_v
+                const rem_segs = Math.max(1, N_seg - s);
+                const rem_fraction = Math.max(0.15, rem_segs / Math.max(1, N_seg));
+                for (let f = 1; f < fork_count; f++) {
+                    const f_az = base_az + (f * PI2) / fork_count;
+                    const fax = Math.cos(f_az) * pre_rx + Math.sin(f_az) * pre_sx;
+                    const fay = Math.cos(f_az) * pre_ry + Math.sin(f_az) * pre_sy;
+                    const faz = Math.cos(f_az) * pre_rz + Math.sin(f_az) * pre_sz;
+
+                    const f_tan = [0, 0, 0];
+                    rotate_around_axis(f_tan, pre_tx, pre_ty, pre_tz, fax, fay, faz, split_ang * 0.65);
+
+                    const f_r = [0, 0, 0];
+                    rotate_around_axis(f_r, pre_rx, pre_ry, pre_rz, fax, fay, faz, split_ang * 0.65);
+
+                    queue.push({
+                        level,
+                        parent_branch_id: branch_id,
+                        parent_edge_id: edge_id,
+                        parent_attach_t: t_curr,
+                        attach_parent_vertex: curr_v,
+                        start_vertex: -1,
+                        px: next_px,
+                        py: next_py,
+                        pz: next_pz,
+                        tx: f_tan[0],
+                        ty: f_tan[1],
+                        tz: f_tan[2],
+                        rx: f_r[0],
+                        ry: f_r[1],
+                        rz: f_r[2],
+                        length: Math.max(0.15, job.length * rem_fraction),
+                        base_radius: r_curr * 0.78,
+                        start_seg: 0,
+                        total_segs: rem_segs,
+                        initial_arc_s: cur_arc_s,
+                        has_split: true,
+                        child_span_fraction: rem_fraction
+                    });
+                }
+            }
+
+            cur_px = next_px;
+            cur_py = next_py;
+            cur_pz = next_pz;
+            cur_tx = next_tx;
+            cur_ty = next_ty;
+            cur_tz = next_tz;
+            cur_rx = next_rx;
+            cur_ry = next_ry;
+            cur_rz = next_rz;
+            prev_v = curr_v;
+        }
+
+        // Smooth or preserve crisp interior Hermite tangents across consecutive edges of this branch
+        // (preserving branch_edges[0]'s m0 so continuation forks keep their exact fork departure tangent)
+        if (branch_edges.length >= 2) {
+            const kink_sharp = clamp(lvl_cfg.kink_sharpness ?? 0.5, 0.0, 0.92);
+            for (let k = 1; k < branch_edges.length; k++) {
+                const e_prev = branch_edges[k - 1];
+                const e_next = branch_edges[k];
+                const v_mid = branch_vertices[k];
+                const l_prev = Math.max(1e-5, out.segment_length(e_prev));
+                const l_next = Math.max(1e-5, out.segment_length(e_next));
+
+                out.segment_read_m1(SCRATCH_M_PREV, 0, e_prev);
+                out.segment_read_m0(SCRATCH_M_NEXT, 0, e_next);
+
+                const t_in_x = SCRATCH_M_PREV[0] / l_prev;
+                const t_in_y = SCRATCH_M_PREV[1] / l_prev;
+                const t_in_z = SCRATCH_M_PREV[2] / l_prev;
+                const t_out_x = SCRATCH_M_NEXT[0] / l_next;
+                const t_out_y = SCRATCH_M_NEXT[1] / l_next;
+                const t_out_z = SCRATCH_M_NEXT[2] / l_next;
+
+                let tx = t_in_x + t_out_x;
+                let ty = t_in_y + t_out_y;
+                let tz = t_in_z + t_out_z;
+                const t_len = Math.sqrt(tx * tx + ty * ty + tz * tz);
+                if (t_len > 1e-12) {
+                    tx /= t_len;
+                    ty /= t_len;
+                    tz /= t_len;
+
+                    out.node_write_tangent(v_mid, tx, ty, tz);
+
+                    // Blend between smooth C1 average tangent and crisp sympodial kink tangents
+                    let m1x = lerp(tx, t_in_x, kink_sharp);
+                    let m1y = lerp(ty, t_in_y, kink_sharp);
+                    let m1z = lerp(tz, t_in_z, kink_sharp);
+                    const m1_l = Math.sqrt(m1x * m1x + m1y * m1y + m1z * m1z);
+                    if (m1_l > 1e-12) { m1x /= m1_l; m1y /= m1_l; m1z /= m1_l; }
+
+                    let m0x = lerp(tx, t_out_x, kink_sharp);
+                    let m0y = lerp(ty, t_out_y, kink_sharp);
+                    let m0z = lerp(tz, t_out_z, kink_sharp);
+                    const m0_l = Math.sqrt(m0x * m0x + m0y * m0y + m0z * m0z);
+                    if (m0_l > 1e-12) { m0x /= m0_l; m0y /= m0_l; m0z /= m0_l; }
+
+                    out.segment_write_m1(e_prev, m1x * l_prev, m1y * l_prev, m1z * l_prev);
+                    out.segment_write_m0(e_next, m0x * l_next, m0y * l_next, m0z * l_next);
+                }
+            }
+        }
+
+        // Spawn lateral child branches at level + 1 using pre-scheduled attachments
+        const next_level = level + 1;
+        if (scheduled_children.length > 0 && branch_edges.length > 0) {
+            const next_cfg = species.levels[next_level];
+            const t_max = branch_edge_t1[branch_edge_t1.length - 1];
+
+            for (let c = 0; c < scheduled_children.length; c++) {
+                const sc = scheduled_children[c];
+                const t_attach = clamp(sc.t_attach, branch_edge_t0[0], t_max * 0.985);
+                const phi = sc.phi;
+
+                // Find parent edge containing t_attach
+                let seg_idx = 0;
+                for (let i = 0; i < branch_edges.length; i++) {
+                    if (t_attach >= branch_edge_t0[i] && t_attach <= branch_edge_t1[i]) {
+                        seg_idx = i;
+                        break;
+                    }
+                }
+
+                const parent_e = branch_edges[seg_idx];
+                const t0_e = branch_edge_t0[seg_idx];
+                const t1_e = branch_edge_t1[seg_idx];
+                const local_u = clamp((t_attach - t0_e) / Math.max(1e-5, t1_e - t0_e), 0.0, 1.0);
+
+                out.evaluate_segment_position(SCRATCH_POS, 0, parent_e, local_u);
+                out.evaluate_segment_tangent(SCRATCH_TAN, 0, parent_e, local_u);
+
+                const p_v0 = branch_vertices[seg_idx];
+                const p_v1 = branch_vertices[seg_idx + 1];
+                const r_p0 = out.node_read_radius(p_v0);
+                const r_p1 = out.node_read_radius(p_v1);
+                const parent_r_at_attach = lerp(r_p0, r_p1, local_u);
+
+                // Transport parent RMF R vector from p_v0 along parent_e to SCRATCH_POS at local_u
+                out.node_read_position(SCRATCH_P0, 0, p_v0);
+                out.node_read_tangent(SCRATCH_T0, 0, p_v0);
+                out.node_read_frame_r(SCRATCH_R0, 0, p_v0);
+                const p_rx = SCRATCH_R0[0];
+                const p_ry = SCRATCH_R0[1];
+                const p_rz = SCRATCH_R0[2];
+
+                spine_frame_double_reflection(
+                    SCRATCH_RMF, 0,
+                    SCRATCH_P0[0], SCRATCH_P0[1], SCRATCH_P0[2],
+                    SCRATCH_T0[0], SCRATCH_T0[1], SCRATCH_T0[2],
+                    p_rx, p_ry, p_rz,
+                    SCRATCH_POS[0], SCRATCH_POS[1], SCRATCH_POS[2],
+                    SCRATCH_TAN[0], SCRATCH_TAN[1], SCRATCH_TAN[2]
+                );
+                const prx = SCRATCH_RMF[0], pry = SCRATCH_RMF[1], prz = SCRATCH_RMF[2];
+                const psx = SCRATCH_RMF[3], psy = SCRATCH_RMF[4], psz = SCRATCH_RMF[5];
+
+                // Radial direction D_rad in parent cross-section plane
+                const cos_p = Math.cos(phi);
+                const sin_p = Math.sin(phi);
+                let drx = cos_p * prx + sin_p * psx;
+                let dry = cos_p * pry + sin_p * psy;
+                let drz = cos_p * prz + sin_p * psz;
+
+                // Plagiotropic flattening on lateral branches (non-weeping): prevent child shoots
+                // from pointing straight downward from the underside of boughs into the lower trunk
+                if (level >= 1 && crown.envelope_type !== CrownEnvelopeType.Weeping) {
+                    dry = dry < 0.0 ? dry * 0.15 + 0.08 : dry * 0.75 + 0.12;
+                    const dot_tp = drx * SCRATCH_TAN[0] + dry * SCRATCH_TAN[1] + drz * SCRATCH_TAN[2];
+                    drx -= dot_tp * SCRATCH_TAN[0];
+                    dry -= dot_tp * SCRATCH_TAN[1];
+                    drz -= dot_tp * SCRATCH_TAN[2];
+                    const d_len = Math.sqrt(drx * drx + dry * dry + drz * drz);
+                    if (d_len > 1e-6) {
+                        drx /= d_len;
+                        dry /= d_len;
+                        drz /= d_len;
+                    } else {
+                        drx = cos_p * prx + sin_p * psx;
+                        dry = cos_p * pry + sin_p * psy;
+                        drz = cos_p * prz + sin_p * psz;
+                    }
+                }
+
+                // Insertion polar angle alpha from parent tangent T_p toward D_rad
+                const alpha_scale = lvl_cfg.insertion_angle_profile.evaluate(t_attach);
+                const alpha = clamp(
+                    lvl_cfg.insertion_angle * alpha_scale + (rng() * 2.0 - 1.0) * lvl_cfg.insertion_angle_variation,
+                    0.1,
+                    Math.PI * 0.85
+                );
+
+                const cos_a = Math.cos(alpha);
+                const sin_a = Math.sin(alpha);
+                let ctx = cos_a * SCRATCH_TAN[0] + sin_a * drx;
+                let cty = cos_a * SCRATCH_TAN[1] + sin_a * dry;
+                let ctz = cos_a * SCRATCH_TAN[2] + sin_a * drz;
+                const ct_len = Math.sqrt(ctx * ctx + cty * cty + ctz * ctz);
+                if (ct_len > 1e-12) {
+                    ctx /= ct_len;
+                    cty /= ct_len;
+                    ctz /= ct_len;
+                }
+
+                // Initial RMF radial vector for child branch:
+                // R_c = cos(alpha) * D_rad - sin(alpha) * T_p is exact unit length and orthogonal
+                // to T_c = cos(alpha) * T_p + sin(alpha) * D_rad for all alpha in [0, pi],
+                // avoiding any singularity at alpha = pi/2.
+                let crx = cos_a * drx - sin_a * SCRATCH_TAN[0];
+                let cry = cos_a * dry - sin_a * SCRATCH_TAN[1];
+                let crz = cos_a * drz - sin_a * SCRATCH_TAN[2];
+                const cr_dot = crx * ctx + cry * cty + crz * ctz;
+                crx -= cr_dot * ctx;
+                cry -= cr_dot * cty;
+                crz -= cr_dot * ctz;
+                const cr_len = Math.sqrt(crx * crx + cry * cry + crz * crz);
+                if (cr_len > 1e-12) {
+                    crx /= cr_len;
+                    cry /= cr_len;
+                    crz /= cr_len;
+                }
+
+                // Compute child branch length modulated by length_profile and crown envelope at mid-span height
+                const est_mid_y = SCRATCH_POS[1] + Math.max(0.0, cty) * next_cfg.length * 0.5;
+                const h_norm = clamp((est_mid_y - crown.base_height) / Math.max(0.1, crown.height), 0.0, 1.0);
+                const env_scale = level === 0
+                    ? crown_envelope_evaluate(crown.envelope_type, h_norm)
+                    : lerp(1.0, crown_envelope_evaluate(crown.envelope_type, h_norm), 0.5);
+                const prof_scale = Math.max(0.1, next_cfg.length_profile.evaluate(t_attach));
+                const var_scale = 1.0 + (rng() * 2.0 - 1.0) * next_cfg.length_variance;
+                const child_len = Math.max(0.15, next_cfg.length * prof_scale * env_scale * var_scale);
+
+                const child_base_r = Math.min(
+                    parent_r_at_attach * 0.85,
+                    Math.max(0.003, child_len * next_cfg.radius_ratio)
+                );
+
+                queue.push({
+                    level: next_level,
+                    parent_branch_id: branch_id,
+                    parent_edge_id: parent_e,
+                    parent_attach_t: t_attach,
+                    attach_parent_vertex: p_v0,
+                    start_vertex: -1,
+                    px: SCRATCH_POS[0],
+                    py: SCRATCH_POS[1],
+                    pz: SCRATCH_POS[2],
+                    tx: ctx,
+                    ty: cty,
+                    tz: ctz,
+                    rx: crx,
+                    ry: cry,
+                    rz: crz,
+                    length: child_len,
+                    base_radius: child_base_r,
+                    start_seg: 0,
+                    total_segs: Math.max(1, next_cfg.segments),
+                    initial_arc_s: 0.0,
+                    has_split: false
+                });
+            }
+        }
+    }
+
+    // Bottom-up Pipe Model radius calculation & blending
+    tree_skeleton_compute_pipe_radii(out, species);
+
+    return out;
+}