@woosh/meep-engine 3.52.0 → 3.54.0

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

@@ -0,0 +1,27 @@
+/**
+ * Evaluates the normalized radial crown envelope profile $S_{\text{env}}(h_{\text{norm}}) \in [0.05, 1.0]$
+ * at normalized crown height $h_{\text{norm}} \in [0, 1]$ (0 = base of crown, 1 = apex of crown).
+ *
+ * Implements Weber & Penn (1995) / SpeedTree botanical crown envelope shapes.
+ *
+ * @param {CrownEnvelopeType|number} envelope_type
+ * @param {number} h_norm normalized height in [0, 1]
+ * @param {number} [prune_width_peak=0.6] normalized height of maximum crown width for asymmetric envelopes
+ * @param {number} [power_low=1.5] lower envelope exponent
+ * @param {number} [power_high=1.5] upper envelope exponent
+ * @returns {number} radial envelope factor in [0.05, 1.0]
+ */
+export function crown_envelope_evaluate(envelope_type: CrownEnvelopeType | number, h_norm: number, prune_width_peak?: number, power_low?: number, power_high?: number): number;
+/**
+ * Evaluates a signed distance approximation to the 3D crown envelope around the `+Y` trunk axis.
+ * Negative inside the crown envelope, positive outside.
+ *
+ * @param {number} px
+ * @param {number} py
+ * @param {number} pz
+ * @param {import("../config/CrownConfig.js").CrownConfig} crown_config
+ * @returns {number}
+ */
+export function crown_envelope_sdf(px: number, py: number, pz: number, crown_config: import("../config/CrownConfig.js").CrownConfig): number;
+import { CrownEnvelopeType } from "../config/CrownEnvelopeType.js";
+//# sourceMappingURL=crown_envelope_evaluate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"crown_envelope_evaluate.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/skeleton/crown_envelope_evaluate.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;GAYG;AACH,uDAPW,iBAAiB,GAAC,MAAM,UACxB,MAAM,qBACN,MAAM,cACN,MAAM,eACN,MAAM,GACJ,MAAM,CAyElB;AAED;;;;;;;;;GASG;AACH,uCANW,MAAM,MACN,MAAM,MACN,MAAM,gBACN,OAAO,0BAA0B,EAAE,WAAW,GAC5C,MAAM,CAuBlB;kCAvHiC,gCAAgC"}

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

@@ -0,0 +1,121 @@
+import { clamp } from "../../../core/math/clamp.js";
+import { CrownEnvelopeType } from "../config/CrownEnvelopeType.js";
+
+/**
+ * Evaluates the normalized radial crown envelope profile $S_{\text{env}}(h_{\text{norm}}) \in [0.05, 1.0]$
+ * at normalized crown height $h_{\text{norm}} \in [0, 1]$ (0 = base of crown, 1 = apex of crown).
+ *
+ * Implements Weber & Penn (1995) / SpeedTree botanical crown envelope shapes.
+ *
+ * @param {CrownEnvelopeType|number} envelope_type
+ * @param {number} h_norm normalized height in [0, 1]
+ * @param {number} [prune_width_peak=0.6] normalized height of maximum crown width for asymmetric envelopes
+ * @param {number} [power_low=1.5] lower envelope exponent
+ * @param {number} [power_high=1.5] upper envelope exponent
+ * @returns {number} radial envelope factor in [0.05, 1.0]
+ */
+export function crown_envelope_evaluate(
+	envelope_type,
+	h_norm,
+	prune_width_peak = 0.6,
+	power_low = 1.5,
+	power_high = 1.5
+) {
+	const h = clamp(h_norm, 0.0, 1.0);
+	let val = 1.0;
+
+	switch (envelope_type) {
+		case CrownEnvelopeType.Conical:
+			val = 0.06 + 0.94 * (1.0 - h);
+			break;
+
+		case CrownEnvelopeType.Spherical:
+			val = 0.2 + 0.8 * Math.sin(Math.PI * h);
+			break;
+
+		case CrownEnvelopeType.Hemispherical:
+			val = 0.2 + 0.8 * Math.sin(0.5 * Math.PI * (1.0 - h));
+			break;
+
+		case CrownEnvelopeType.Cylindrical:
+			val = 1.0;
+			break;
+
+		case CrownEnvelopeType.TaperedCylindrical:
+			val = 0.5 + 0.5 * (1.0 - h);
+			break;
+
+		case CrownEnvelopeType.Flame:
+			if (h <= 0.7) {
+				val = h / 0.7;
+			} else {
+				val = (1.0 - h) / 0.3;
+			}
+			val = 0.15 + 0.85 * val;
+			break;
+
+		case CrownEnvelopeType.InverseConical:
+			val = 0.2 + 0.8 * h;
+			break;
+
+		case CrownEnvelopeType.TendFlame:
+			if (h <= 0.7) {
+				val = 0.5 + 0.5 * (h / 0.7);
+			} else {
+				val = 0.5 + 0.5 * ((1.0 - h) / 0.3);
+			}
+			break;
+
+		case CrownEnvelopeType.Weeping: {
+			const peak = clamp(prune_width_peak, 0.1, 0.9);
+			if (h < peak) {
+				const u = (peak - h) / peak;
+				val = 1.0 - Math.pow(u, power_low);
+			} else {
+				const u = (h - peak) / (1.0 - peak);
+				val = 1.0 - Math.pow(u, power_high);
+			}
+			val = 0.18 + 0.82 * Math.max(0.0, val);
+			break;
+		}
+
+		default:
+			val = 0.2 + 0.8 * Math.sin(Math.PI * h);
+			break;
+	}
+
+	return clamp(val, 0.05, 1.0);
+}
+
+/**
+ * Evaluates a signed distance approximation to the 3D crown envelope around the `+Y` trunk axis.
+ * Negative inside the crown envelope, positive outside.
+ *
+ * @param {number} px
+ * @param {number} py
+ * @param {number} pz
+ * @param {import("../config/CrownConfig.js").CrownConfig} crown_config
+ * @returns {number}
+ */
+export function crown_envelope_sdf(px, py, pz, crown_config) {
+	const base_y = crown_config.base_height;
+	const height = Math.max(0.1, crown_config.height);
+	const max_r = Math.max(0.1, crown_config.radius);
+
+	const h_norm = (py - base_y) / height;
+	const r_horiz = Math.sqrt(px * px + pz * pz);
+	const r_env = max_r * crown_envelope_evaluate(crown_config.envelope_type, clamp(h_norm, 0.0, 1.0));
+
+	const d_radial = r_horiz - r_env;
+	let d_vert = 0.0;
+	if (py < base_y) {
+		d_vert = base_y - py;
+	} else if (py > base_y + height) {
+		d_vert = py - (base_y + height);
+	}
+
+	if (d_vert > 0.0 && d_radial > 0.0) {
+		return Math.sqrt(d_radial * d_radial + d_vert * d_vert);
+	}
+	return Math.max(d_radial, d_vert > 0.0 ? d_vert : (Math.abs(h_norm - 0.5) - 0.5) * height);
+}

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

@@ -0,0 +1,32 @@
+/**
+ * Computes a fourth-order accurate Rotation-Minimizing Frame (RMF) along a 3D spine step
+ * using the Double Reflection method (Wang, Jüttler, Zheng, & Liu, ACM TOG 2008).
+ *
+ * Writes the orthonormal cross-section basis `[Rx1, Ry1, Rz1, Sx1, Sy1, Sz1]` at `(x1, y1, z1)`
+ * into `out` starting at `out_offset`, where `S1 = T1 x R1`.
+ *
+ * Includes full numerical guards for:
+ * - Zero displacement (`||x1 - x0||^2 <= 1e-12`): delegates to `tube_frame_transport`.
+ * - Anti-parallel reflected tangent (`||T1 - T0_L||^2 <= 1e-12`): skips second reflection.
+ * - Gram-Schmidt re-orthonormalization against `T1` so `R1` is strictly unit and perpendicular to `T1`.
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset
+ * @param {number} x0 previous position X
+ * @param {number} y0 previous position Y
+ * @param {number} z0 previous position Z
+ * @param {number} tx0 previous unit tangent X
+ * @param {number} ty0 previous unit tangent Y
+ * @param {number} tz0 previous unit tangent Z
+ * @param {number} rx0 previous unit radial reference X
+ * @param {number} ry0 previous unit radial reference Y
+ * @param {number} rz0 previous unit radial reference Z
+ * @param {number} x1 current position X
+ * @param {number} y1 current position Y
+ * @param {number} z1 current position Z
+ * @param {number} tx1 current unit tangent X
+ * @param {number} ty1 current unit tangent Y
+ * @param {number} tz1 current unit tangent Z
+ */
+export function spine_frame_double_reflection(out: number[] | Float32Array | Float64Array, out_offset: number, x0: number, y0: number, z0: number, tx0: number, ty0: number, tz0: number, rx0: number, ry0: number, rz0: number, x1: number, y1: number, z1: number, tx1: number, ty1: number, tz1: number): void;
+//# sourceMappingURL=spine_frame_double_reflection.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"spine_frame_double_reflection.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/skeleton/spine_frame_double_reflection.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,mDAlBW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,QAsDhB"}

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

@@ -0,0 +1,87 @@
+import { tube_frame_transport } from "../../../engine/graphics/trail/tube/tube_frame.js";
+
+const DEGENERATE_EPSILON = 1e-12;
+
+/**
+ * Computes a fourth-order accurate Rotation-Minimizing Frame (RMF) along a 3D spine step
+ * using the Double Reflection method (Wang, Jüttler, Zheng, & Liu, ACM TOG 2008).
+ *
+ * Writes the orthonormal cross-section basis `[Rx1, Ry1, Rz1, Sx1, Sy1, Sz1]` at `(x1, y1, z1)`
+ * into `out` starting at `out_offset`, where `S1 = T1 x R1`.
+ *
+ * Includes full numerical guards for:
+ * - Zero displacement (`||x1 - x0||^2 <= 1e-12`): delegates to `tube_frame_transport`.
+ * - Anti-parallel reflected tangent (`||T1 - T0_L||^2 <= 1e-12`): skips second reflection.
+ * - Gram-Schmidt re-orthonormalization against `T1` so `R1` is strictly unit and perpendicular to `T1`.
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset
+ * @param {number} x0 previous position X
+ * @param {number} y0 previous position Y
+ * @param {number} z0 previous position Z
+ * @param {number} tx0 previous unit tangent X
+ * @param {number} ty0 previous unit tangent Y
+ * @param {number} tz0 previous unit tangent Z
+ * @param {number} rx0 previous unit radial reference X
+ * @param {number} ry0 previous unit radial reference Y
+ * @param {number} rz0 previous unit radial reference Z
+ * @param {number} x1 current position X
+ * @param {number} y1 current position Y
+ * @param {number} z1 current position Z
+ * @param {number} tx1 current unit tangent X
+ * @param {number} ty1 current unit tangent Y
+ * @param {number} tz1 current unit tangent Z
+ */
+export function spine_frame_double_reflection(
+    out,
+    out_offset,
+    x0, y0, z0,
+    tx0, ty0, tz0,
+    rx0, ry0, rz0,
+    x1, y1, z1,
+    tx1, ty1, tz1
+) {
+    const v1x = x1 - x0;
+    const v1y = y1 - y0;
+    const v1z = z1 - z0;
+    const c1 = v1x * v1x + v1y * v1y + v1z * v1z;
+
+    if (c1 <= DEGENERATE_EPSILON) {
+        tube_frame_transport(out, out_offset, tx1, ty1, tz1, rx0, ry0, rz0);
+        return;
+    }
+
+    const two_inv_c1 = 2.0 / c1;
+    const dot_v1_r0 = v1x * rx0 + v1y * ry0 + v1z * rz0;
+    const dot_v1_t0 = v1x * tx0 + v1y * ty0 + v1z * tz0;
+
+    // First Householder reflection across hyperplane bisecting x0 and x1
+    const rLx = rx0 - two_inv_c1 * dot_v1_r0 * v1x;
+    const rLy = ry0 - two_inv_c1 * dot_v1_r0 * v1y;
+    const rLz = rz0 - two_inv_c1 * dot_v1_r0 * v1z;
+
+    const tLx = tx0 - two_inv_c1 * dot_v1_t0 * v1x;
+    const tLy = ty0 - two_inv_c1 * dot_v1_t0 * v1y;
+    const tLz = tz0 - two_inv_c1 * dot_v1_t0 * v1z;
+
+    // Second Householder reflection aligning tL with t1
+    const v2x = tx1 - tLx;
+    const v2y = ty1 - tLy;
+    const v2z = tz1 - tLz;
+    const c2 = v2x * v2x + v2y * v2y + v2z * v2z;
+
+    let rx1 = rLx;
+    let ry1 = rLy;
+    let rz1 = rLz;
+
+    if (c2 > DEGENERATE_EPSILON) {
+        const two_inv_c2 = 2.0 / c2;
+        const dot_v2_rL = v2x * rLx + v2y * rLy + v2z * rLz;
+        rx1 = rLx - two_inv_c2 * dot_v2_rL * v2x;
+        ry1 = rLy - two_inv_c2 * dot_v2_rL * v2y;
+        rz1 = rLz - two_inv_c2 * dot_v2_rL * v2z;
+    }
+
+    // Gram-Schmidt projection + normalization via tube_frame_transport to prevent floating-point drift
+    tube_frame_transport(out, out_offset, tx1, ty1, tz1, rx1, ry1, rz1);
+}

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

@@ -0,0 +1,33 @@
+/**
+ * Selects up to `max_joints` structural skeleton nodes in strict topological pre-order
+ * (`joint_parents[j] < j`) from `skeleton.graph` for GPU skeletal wind animation (`Skin`),
+ * and writes `[primary_joint_index, parent_joint_index]` into `skeleton.attr_node_joint` for every node.
+ *
+ * @param {import("./TreeSkeleton.js").TreeSkeleton} skeleton
+ * @param {number} [max_joints=32]
+ * @returns {{
+ *   joint_count: number,
+ *   joint_vertex_ids: Int32Array,
+ *   joint_parents: Int32Array,
+ *   joint_positions: Float32Array,
+ *   joint_tangents: Float32Array,
+ *   joint_levels: Uint8Array,
+ *   joint_phases: Float32Array,
+ *   joint_t_norms: Float32Array,
+ *   joint_radii: Float32Array,
+ *   joint_lengths: Float32Array
+ * }}
+ */
+export function tree_skeleton_assign_skin_joints(skeleton: import("./TreeSkeleton.js").TreeSkeleton, max_joints?: number): {
+    joint_count: number;
+    joint_vertex_ids: Int32Array;
+    joint_parents: Int32Array;
+    joint_positions: Float32Array;
+    joint_tangents: Float32Array;
+    joint_levels: Uint8Array;
+    joint_phases: Float32Array;
+    joint_t_norms: Float32Array;
+    joint_radii: Float32Array;
+    joint_lengths: Float32Array;
+};
+//# sourceMappingURL=tree_skeleton_assign_skin_joints.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tree_skeleton_assign_skin_joints.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/skeleton/tree_skeleton_assign_skin_joints.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,2DAfW,OAAO,mBAAmB,EAAE,YAAY,eACxC,MAAM,GACJ;IACZ,WAAe,EAAE,MAAM,CAAC;IACxB,gBAAoB,EAAE,UAAU,CAAC;IACjC,aAAiB,EAAE,UAAU,CAAC;IAC9B,eAAmB,EAAE,YAAY,CAAC;IAClC,cAAkB,EAAE,YAAY,CAAC;IACjC,YAAgB,EAAE,UAAU,CAAC;IAC7B,YAAgB,EAAE,YAAY,CAAC;IAC/B,aAAiB,EAAE,YAAY,CAAC;IAChC,WAAe,EAAE,YAAY,CAAC;IAC9B,aAAiB,EAAE,YAAY,CAAA;CAC5B,CAsLH"}

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

@@ -0,0 +1,205 @@
+const SCRATCH_POS = new Float32Array(3);
+const SCRATCH_TAN = new Float32Array(3);
+const SCRATCH_PARAM = new Float32Array(3);
+
+/**
+ * Selects up to `max_joints` structural skeleton nodes in strict topological pre-order
+ * (`joint_parents[j] < j`) from `skeleton.graph` for GPU skeletal wind animation (`Skin`),
+ * and writes `[primary_joint_index, parent_joint_index]` into `skeleton.attr_node_joint` for every node.
+ *
+ * @param {import("./TreeSkeleton.js").TreeSkeleton} skeleton
+ * @param {number} [max_joints=32]
+ * @returns {{
+ *   joint_count: number,
+ *   joint_vertex_ids: Int32Array,
+ *   joint_parents: Int32Array,
+ *   joint_positions: Float32Array,
+ *   joint_tangents: Float32Array,
+ *   joint_levels: Uint8Array,
+ *   joint_phases: Float32Array,
+ *   joint_t_norms: Float32Array,
+ *   joint_radii: Float32Array,
+ *   joint_lengths: Float32Array
+ * }}
+ */
+export function tree_skeleton_assign_skin_joints(skeleton, max_joints = 32) {
+    const vertex_count = skeleton.node_count;
+    const budget = Math.max(1, max_joints | 0);
+
+    if (vertex_count === 0) {
+        return {
+            joint_count: 1,
+            joint_vertex_ids: new Int32Array([0]),
+            joint_parents: new Int32Array([-1]),
+            joint_positions: new Float32Array([0, 0, 0]),
+            joint_tangents: new Float32Array([0, 1, 0]),
+            joint_levels: new Uint8Array([0]),
+            joint_phases: new Float32Array([0]),
+            joint_t_norms: new Float32Array([0]),
+            joint_radii: new Float32Array([0.1]),
+            joint_lengths: new Float32Array([1.0])
+        };
+    }
+
+    // Mark candidate nodes by branch-aware round-robin so the joint budget is distributed
+    // across the trunk (2-4 joints) AND all primary boughs around 360° of the crown,
+    // then iterate node IDs in ascending order to guarantee topological pre-order (parent < child).
+    const is_selected = new Uint8Array(vertex_count);
+    let selected_count = 0;
+
+    // Always include node 0 (trunk root) as joint 0
+    is_selected[0] = 1;
+    selected_count = 1;
+
+    const branch_count = skeleton.branch_count;
+
+    // 1. Trunk / level-0 branches: pick up to 3 evenly spaced milestones (t ~ 0.35, 0.68, 1.0)
+    const max_trunk_joints = Math.min(budget, Math.max(2, Math.min(5, Math.floor(budget * 0.2))));
+    const trunk_targets = [0.38, 0.72, 1.0];
+    for (let m = 0; m < trunk_targets.length && selected_count < max_trunk_joints; m++) {
+        const target_t = trunk_targets[m];
+        for (let b = 0; b < branch_count && selected_count < max_trunk_joints; b++) {
+            if (skeleton.branch_level[b] !== 0) continue;
+            const nodes = [];
+            const edges = [];
+            skeleton.collect_branch_chain(b, nodes, edges);
+            let best_v = -1;
+            let best_dist = Infinity;
+            for (let i = 1; i < nodes.length; i++) {
+                const v = nodes[i];
+                if (is_selected[v]) continue;
+                const d = Math.abs(skeleton.node_t_norm(v) - target_t);
+                if (d < best_dist) {
+                    best_dist = d;
+                    best_v = v;
+                }
+            }
+            if (best_v >= 0 && best_dist <= 0.28) {
+                is_selected[best_v] = 1;
+                selected_count++;
+            }
+        }
+    }
+
+    // 2. Primary boughs (level === 1): first select root hinge nodes[0] so every bough pivots at its trunk collar,
+    // then select a mid-bough node (~0.55) on a second pass for multi-segment bough bending.
+    for (let pass = 0; pass < 2 && selected_count < budget; pass++) {
+        for (let b = 0; b < branch_count && selected_count < budget; b++) {
+            if (skeleton.branch_level[b] !== 1) continue;
+            const nodes = [];
+            const edges = [];
+            skeleton.collect_branch_chain(b, nodes, edges);
+            if (nodes.length === 0) continue;
+
+            if (pass === 0) {
+                const root_v = nodes[0];
+                if (!is_selected[root_v]) {
+                    is_selected[root_v] = 1;
+                    selected_count++;
+                }
+            } else if (nodes.length >= 3) {
+                const mid_idx = Math.max(1, Math.min(nodes.length - 1, Math.round((nodes.length - 1) * 0.55)));
+                const mid_v = nodes[mid_idx];
+                if (!is_selected[mid_v]) {
+                    is_selected[mid_v] = 1;
+                    selected_count++;
+                }
+            }
+        }
+    }
+
+    // 3. Secondary branches (level >= 2): select root hinge nodes[0] across remaining budget
+    for (let b = 0; b < branch_count && selected_count < budget; b++) {
+        if (skeleton.branch_level[b] < 2) continue;
+        const root_v = skeleton.branch_root_vertex[b];
+        if (root_v >= 0 && !is_selected[root_v]) {
+            is_selected[root_v] = 1;
+            selected_count++;
+        }
+    }
+
+    // 4. If budget still has room, fill any remaining nodes in topological order
+    for (let v = 1; v < vertex_count && selected_count < budget; v++) {
+        if (!is_selected[v]) {
+            is_selected[v] = 1;
+            selected_count++;
+        }
+    }
+
+    const joint_count = selected_count;
+    const joint_vertex_ids = new Int32Array(joint_count);
+    const joint_parents = new Int32Array(joint_count);
+    const joint_positions = new Float32Array(joint_count * 3);
+    const joint_tangents = new Float32Array(joint_count * 3);
+    const joint_levels = new Uint8Array(joint_count);
+    const joint_phases = new Float32Array(joint_count);
+    const joint_t_norms = new Float32Array(joint_count);
+    const joint_radii = new Float32Array(joint_count);
+    const joint_lengths = new Float32Array(joint_count);
+
+    // Map each node to its active joint index (or closest selected ancestor joint index in `skeleton.graph`)
+    const vertex_active_joint = new Int32Array(vertex_count);
+    let j_cursor = 0;
+
+    for (let v = 0; v < vertex_count; v++) {
+        const parent_v = skeleton.node_parent_vertex(v);
+        const ancestor_joint = (parent_v >= 0 && parent_v < v) ? vertex_active_joint[parent_v] : 0;
+
+        if (is_selected[v]) {
+            const j = j_cursor++;
+            const pj = v === 0 ? -1 : ancestor_joint;
+            joint_vertex_ids[j] = v;
+            joint_parents[j] = pj;
+
+            skeleton.node_read_position(SCRATCH_POS, 0, v);
+            skeleton.node_read_tangent(SCRATCH_TAN, 0, v);
+            skeleton.node_read_spine_param(SCRATCH_PARAM, 0, v);
+
+            joint_positions[j * 3] = SCRATCH_POS[0];
+            joint_positions[j * 3 + 1] = SCRATCH_POS[1];
+            joint_positions[j * 3 + 2] = SCRATCH_POS[2];
+
+            joint_tangents[j * 3] = SCRATCH_TAN[0];
+            joint_tangents[j * 3 + 1] = SCRATCH_TAN[1];
+            joint_tangents[j * 3 + 2] = SCRATCH_TAN[2];
+
+            const b_v = skeleton.node_branch_id(v);
+            joint_levels[j] = skeleton.node_level(v);
+            joint_t_norms[j] = b_v > 0 ? Math.max(0.55, SCRATCH_PARAM[0]) : SCRATCH_PARAM[0];
+            joint_phases[j] = SCRATCH_PARAM[2];
+            joint_radii[j] = Math.max(0.005, skeleton.node_read_radius(v));
+
+            if (b_v > 0 && b_v < skeleton.branch_count) {
+                joint_lengths[j] = Math.max(0.2, skeleton.branch_length[b_v]);
+            } else if (pj >= 0) {
+                const dx = SCRATCH_POS[0] - joint_positions[pj * 3];
+                const dy = SCRATCH_POS[1] - joint_positions[pj * 3 + 1];
+                const dz = SCRATCH_POS[2] - joint_positions[pj * 3 + 2];
+                joint_lengths[j] = Math.max(0.2, Math.hypot(dx, dy, dz));
+            } else {
+                joint_lengths[j] = 1.0;
+            }
+
+            vertex_active_joint[v] = j;
+            const p_joint = pj >= 0 ? pj : 0;
+            skeleton.node_write_joint(v, j, p_joint);
+        } else {
+            vertex_active_joint[v] = ancestor_joint;
+            const p_joint = joint_parents[ancestor_joint] >= 0 ? joint_parents[ancestor_joint] : 0;
+            skeleton.node_write_joint(v, ancestor_joint, p_joint);
+        }
+    }
+
+    return {
+        joint_count,
+        joint_vertex_ids,
+        joint_parents,
+        joint_positions,
+        joint_tangents,
+        joint_levels,
+        joint_phases,
+        joint_t_norms,
+        joint_radii,
+        joint_lengths
+    };
+}

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

@@ -0,0 +1,17 @@
+/**
+ * Enforces Da Vinci's pipe-model cross-sectional area conservation across a `TreeSkeleton`
+ * in a bottom-up post-order pass:
+ *
+ * $$r_{\text{parent}}^\alpha = \sum_{k} r_{\text{child}, k}^\alpha$$
+ *
+ * Blended with each node's initial parametric taper radius via `pipe_model_weight`, while
+ * preserving boundary conditions at both the branch base ($t = 0$) and terminal shoot apex ($t = 1$)
+ * so neither trunk nor branch tips inflate into blunt stubs.
+ *
+ * @param {import("./TreeSkeleton.js").TreeSkeleton} skeleton
+ * @param {TreeSpeciesConfig} [config]
+ * @returns {import("./TreeSkeleton.js").TreeSkeleton}
+ */
+export function tree_skeleton_compute_pipe_radii(skeleton: import("./TreeSkeleton.js").TreeSkeleton, config?: TreeSpeciesConfig): import("./TreeSkeleton.js").TreeSkeleton;
+import { TreeSpeciesConfig } from "../config/TreeSpeciesConfig.js";
+//# sourceMappingURL=tree_skeleton_compute_pipe_radii.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tree_skeleton_compute_pipe_radii.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/skeleton/tree_skeleton_compute_pipe_radii.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;GAaG;AACH,2DAJW,OAAO,mBAAmB,EAAE,YAAY,WACxC,iBAAiB,GACf,OAAO,mBAAmB,EAAE,YAAY,CA6LpD;kCA3MiC,gCAAgC"}