@woosh/meep-engine 3.57.0 → 3.58.0

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

@@ -13,14 +13,27 @@
  * - a joint rotates its whole span about its own pivot, so a bend `theta` at a distance `x` along the span lands
  *   `theta * x` off, and a new joint starts where that error would pass the tolerance.
  *
- * The tolerance is `species.wind.deflection_tolerance`, a distance in metres. So stiff or bare wood takes few joints,
- * slender leafy wood many, and a tall tree, whose bends move more, more than a small one. Node 0, the trunk
+ * The tolerance is `species.wind.deflection_tolerance`, a distance in metres, unless `options.tolerance` gives
+ * another. So stiff or bare wood takes few joints, slender leafy wood many, and a tall tree, whose bends move more,
+ * more than a small one.
+ *
+ * An LOD rigs the wood it draws (`options.rings`): joints sit only on drawn branches, no further out than their bark,
+ * and what the LOD leaves undrawn moves with the drawn wood it hangs from. A coarser LOD keeps a subset of the finer
+ * one's joints (`options.within`): its walk places a joint only where the finer rig has one, the first past where
+ * the error passes its tolerance, so switching between them keeps every joint both share. Node 0, the trunk
  * base, is always joint 0 and stays anchored. Branches of a `root` generator never get a joint, so surface roots stay
  * bound to their parent's stationary base joint and do not lift out of the soil in wind. `species.wind.max_joints` is
  * only a safety net: past it, the joints that would hide the least sway are dropped.
  *
  * @param {import("./TreeSkeleton.js").TreeSkeleton} skeleton
  * @param {TreeSpeciesConfig} species
+ * @param {Object} [options]
+ * @param {number} [options.tolerance] m, the sway a joint may leave hidden; `species.wind.deflection_tolerance` by
+ *        default
+ * @param {Map<number, Array<{t_norm: number}>>|null} [options.rings] the wood an LOD draws
+ *        (`tree_mesh_compute_branch_rings`), or `null` for all of it
+ * @param {ArrayLike<number>|null} [options.within] the nodes joints may sit at: a finer LOD's `joint_vertex_ids`, or
+ *        `null` for any
  * @returns {{
  *   joint_count: number,
  *   joint_vertex_ids: Int32Array,
@@ -30,11 +43,21 @@
  *   joint_levels: Uint8Array,
  *   joint_phases: Float32Array,
  *   joint_compliance: Float32Array,
- *   joint_natural_frequency: Float32Array
- * }} `joint_compliance` (rad / (m/s)^2) and `joint_natural_frequency` (rad/s) are each joint's cantilever
+ *   joint_natural_frequency: Float32Array,
+ *   joint_rotation: Float32Array,
+ *   node_joints: Uint16Array
+ * }} `joint_rotation` is how far each joint turns its span in the reference wind and `node_joints` the
+ * `[primary, parent]` pair it wrote on every node, both of which `tree_skeleton_bind_skin_joints` writes back;
+ * `joint_compliance` (rad / (m/s)^2) and `joint_natural_frequency` (rad/s) are each joint's cantilever
  * wind mechanics, see `tree_skeleton_compute_joint_mechanics`
  */
-export function tree_skeleton_assign_skin_joints(skeleton: import("./TreeSkeleton.js").TreeSkeleton, species: TreeSpeciesConfig): {
+export function tree_skeleton_assign_skin_joints(skeleton: import("./TreeSkeleton.js").TreeSkeleton, species: TreeSpeciesConfig, options?: {
+    tolerance?: number;
+    rings?: Map<number, Array<{
+        t_norm: number;
+    }>> | null;
+    within?: ArrayLike<number> | null;
+}): {
     joint_count: number;
     joint_vertex_ids: Int32Array;
     joint_parents: Int32Array;
@@ -44,6 +67,8 @@ export function tree_skeleton_assign_skin_joints(skeleton: import("./TreeSkeleto
     joint_phases: Float32Array;
     joint_compliance: Float32Array;
     joint_natural_frequency: Float32Array;
+    joint_rotation: Float32Array;
+    node_joints: Uint16Array;
 };
 import { TreeSpeciesConfig } from "../config/TreeSpeciesConfig.js";
 //# sourceMappingURL=tree_skeleton_assign_skin_joints.d.ts.map

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

@@ -1 +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":"AAaA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,2DAfW,OAAO,mBAAmB,EAAE,YAAY,WACxC,iBAAiB,GACf;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,gBAAoB,EAAE,YAAY,CAAC;IACnC,uBAA2B,EAAE,YAAY,CAAA;CACtC,CAiMH;kCA9OiC,gCAAgC"}
+{"version":3,"file":"tree_skeleton_assign_skin_joints.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/skeleton/tree_skeleton_assign_skin_joints.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,2DA1BW,OAAO,mBAAmB,EAAE,YAAY,WACxC,iBAAiB;IAEA,SAAS,GAA1B,MAAM;IAE8C,KAAK,GAAzD,IAAI,MAAM,EAAE,MAAM;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,CAAC,CAAC,GAAC,IAAI;IAER,MAAM,GAAvC,UAAU,MAAM,CAAC,GAAC,IAAI;IAEpB;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,gBAAoB,EAAE,YAAY,CAAC;IACnC,uBAA2B,EAAE,YAAY,CAAC;IAC1C,cAAkB,EAAE,YAAY,CAAC;IACjC,WAAe,EAAE,WAAW,CAAA;CACzB,CAsNH;kCAlRiC,gCAAgC"}

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

@@ -26,14 +26,27 @@ const SCRATCH_PARAM = new Float32Array(3);
  * - a joint rotates its whole span about its own pivot, so a bend `theta` at a distance `x` along the span lands
  *   `theta * x` off, and a new joint starts where that error would pass the tolerance.
  *
- * The tolerance is `species.wind.deflection_tolerance`, a distance in metres. So stiff or bare wood takes few joints,
- * slender leafy wood many, and a tall tree, whose bends move more, more than a small one. Node 0, the trunk
+ * The tolerance is `species.wind.deflection_tolerance`, a distance in metres, unless `options.tolerance` gives
+ * another. So stiff or bare wood takes few joints, slender leafy wood many, and a tall tree, whose bends move more,
+ * more than a small one.
+ *
+ * An LOD rigs the wood it draws (`options.rings`): joints sit only on drawn branches, no further out than their bark,
+ * and what the LOD leaves undrawn moves with the drawn wood it hangs from. A coarser LOD keeps a subset of the finer
+ * one's joints (`options.within`): its walk places a joint only where the finer rig has one, the first past where
+ * the error passes its tolerance, so switching between them keeps every joint both share. Node 0, the trunk
  * base, is always joint 0 and stays anchored. Branches of a `root` generator never get a joint, so surface roots stay
  * bound to their parent's stationary base joint and do not lift out of the soil in wind. `species.wind.max_joints` is
  * only a safety net: past it, the joints that would hide the least sway are dropped.
  *
  * @param {import("./TreeSkeleton.js").TreeSkeleton} skeleton
  * @param {TreeSpeciesConfig} species
+ * @param {Object} [options]
+ * @param {number} [options.tolerance] m, the sway a joint may leave hidden; `species.wind.deflection_tolerance` by
+ *        default
+ * @param {Map<number, Array<{t_norm: number}>>|null} [options.rings] the wood an LOD draws
+ *        (`tree_mesh_compute_branch_rings`), or `null` for all of it
+ * @param {ArrayLike<number>|null} [options.within] the nodes joints may sit at: a finer LOD's `joint_vertex_ids`, or
+ *        `null` for any
  * @returns {{
  *   joint_count: number,
  *   joint_vertex_ids: Int32Array,
@@ -43,11 +56,15 @@ const SCRATCH_PARAM = new Float32Array(3);
  *   joint_levels: Uint8Array,
  *   joint_phases: Float32Array,
  *   joint_compliance: Float32Array,
- *   joint_natural_frequency: Float32Array
- * }} `joint_compliance` (rad / (m/s)^2) and `joint_natural_frequency` (rad/s) are each joint's cantilever
+ *   joint_natural_frequency: Float32Array,
+ *   joint_rotation: Float32Array,
+ *   node_joints: Uint16Array
+ * }} `joint_rotation` is how far each joint turns its span in the reference wind and `node_joints` the
+ * `[primary, parent]` pair it wrote on every node, both of which `tree_skeleton_bind_skin_joints` writes back;
+ * `joint_compliance` (rad / (m/s)^2) and `joint_natural_frequency` (rad/s) are each joint's cantilever
  * wind mechanics, see `tree_skeleton_compute_joint_mechanics`
  */
-export function tree_skeleton_assign_skin_joints(skeleton, species) {
+export function tree_skeleton_assign_skin_joints(skeleton, species, options = {}) {
     const vertex_count = skeleton.node_count;
     const budget = Math.max(1, species.wind.max_joints | 0);
 
@@ -61,11 +78,19 @@ export function tree_skeleton_assign_skin_joints(skeleton, species) {
             joint_levels: new Uint8Array([0]),
             joint_phases: new Float32Array([0]),
             joint_compliance: new Float32Array([0]),
-            joint_natural_frequency: new Float32Array([0])
+            joint_natural_frequency: new Float32Array([0]),
+            joint_rotation: new Float32Array([0]),
+            node_joints: new Uint16Array(0)
         };
     }
 
-    const tolerance = species.wind.deflection_tolerance;
+    const tolerance = options.tolerance ?? species.wind.deflection_tolerance;
+    const rings = options.rings ?? null;
+    let allowed = null;
+    if (options.within !== undefined && options.within !== null) {
+        allowed = new Uint8Array(vertex_count);
+        for (let k = 0; k < options.within.length; k++) allowed[options.within[k]] = 1;
+    }
 
     const segments = tree_skeleton_compute_segment_mechanics(skeleton, species);
     const segment_compliance = new Float64Array(skeleton.segment_count);
@@ -87,6 +112,13 @@ export function tree_skeleton_assign_skin_joints(skeleton, species) {
     let lost_beyond = new Float64Array(17);
     for (let b = 0; b < skeleton.branch_count; b++) {
         if (species.branches[skeleton.branch_generator[b]].root) continue;
+        if (rings !== null && !rings.has(b)) continue;
+        // how far out its bark is drawn
+        let drawn_end = Infinity;
+        if (rings !== null) {
+            const list = rings.get(b);
+            drawn_end = list[list.length - 1].t_norm;
+        }
         skeleton.collect_branch_chain(b, nodes, edges);
         const n = edges.length;
         if (n === 0) continue;
@@ -117,7 +149,8 @@ export function tree_skeleton_assign_skin_joints(skeleton, species) {
         for (let i = 0; i < n; i++) {
             const v = nodes[i];
             // a split fork starts on its parent's node, which is not this branch's to rotate
-            const placeable = v !== 0 && skeleton.node_branch_id(v) === b;
+            const placeable = v !== 0 && skeleton.node_branch_id(v) === b
+                && skeleton.node_t_norm(v) <= drawn_end && (allowed === null || allowed[v] === 1);
             const len = skeleton.segment_length(edges[i]);
             if (!jointed) {
                 if (placeable && lost_beyond[i] > tolerance) {
@@ -214,7 +247,8 @@ export function tree_skeleton_assign_skin_joints(skeleton, species) {
     for (let v = 0; v < vertex_count; v++) {
         joint_rotation[vertex_active_joint[v]] += span_bend[v];
     }
-    skeleton.set_joints(joint_vertex_ids, joint_rotation);
+    const joint_rotation32 = Float32Array.from(joint_rotation);
+    skeleton.set_joints(joint_vertex_ids, joint_rotation32);
 
     tree_skeleton_compute_joint_mechanics(
         skeleton,
@@ -235,6 +269,8 @@ export function tree_skeleton_assign_skin_joints(skeleton, species) {
         joint_levels,
         joint_phases,
         joint_compliance,
-        joint_natural_frequency
+        joint_natural_frequency,
+        joint_rotation: joint_rotation32,
+        node_joints: Uint16Array.from(/** @type {Uint16Array} */ (skeleton.attr_node_joint.data).subarray(0, vertex_count * 2))
     };
 }

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

@@ -0,0 +1,10 @@
+/**
+ * Binds a rig `tree_skeleton_assign_skin_joints` derived back onto its skeleton: every node's `[primary, parent]` joint
+ * pair, and each joint's pivot and turn. A tree whose LODs each have their own rig binds each before meshing it, as the
+ * bark and the cluster cards read their skinning from the nodes.
+ *
+ * @param {import("./TreeSkeleton.js").TreeSkeleton} skeleton the skeleton the rig was derived on
+ * @param {ReturnType<import("./tree_skeleton_assign_skin_joints.js").tree_skeleton_assign_skin_joints>} skin_info
+ */
+export function tree_skeleton_bind_skin_joints(skeleton: import("./TreeSkeleton.js").TreeSkeleton, skin_info: ReturnType<typeof import("./tree_skeleton_assign_skin_joints.js").tree_skeleton_assign_skin_joints>): void;
+//# sourceMappingURL=tree_skeleton_bind_skin_joints.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tree_skeleton_bind_skin_joints.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/skeleton/tree_skeleton_bind_skin_joints.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,yDAHW,OAAO,mBAAmB,EAAE,YAAY,aACxC,mGAA4F,QAKtG"}

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

@@ -0,0 +1,12 @@
+/**
+ * Binds a rig `tree_skeleton_assign_skin_joints` derived back onto its skeleton: every node's `[primary, parent]` joint
+ * pair, and each joint's pivot and turn. A tree whose LODs each have their own rig binds each before meshing it, as the
+ * bark and the cluster cards read their skinning from the nodes.
+ *
+ * @param {import("./TreeSkeleton.js").TreeSkeleton} skeleton the skeleton the rig was derived on
+ * @param {ReturnType<import("./tree_skeleton_assign_skin_joints.js").tree_skeleton_assign_skin_joints>} skin_info
+ */
+export function tree_skeleton_bind_skin_joints(skeleton, skin_info) {
+    /** @type {Uint16Array} */ (skeleton.attr_node_joint.data).set(skin_info.node_joints);
+    skeleton.set_joints(skin_info.joint_vertex_ids, skin_info.joint_rotation);
+}

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

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

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

@@ -385,7 +385,8 @@ export function tree_skeleton_grow(config = new TreeSpeciesConfig(), out = new T
         outgoing_rules[g].sort(compare_rule_target);
     }
 
-    const trunk_len = Math.max(0.2, lvl0.length * (1.0 + (rng() * 2.0 - 1.0) * lvl0.length_variance));
+    // a seed leader is a shoot a few centimetres long
+    const trunk_len = Math.max(1e-3, 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);

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

@@ -5,6 +5,10 @@
  * the wind rig treat the system as one twig layer. Every carrier and axis records where each of its annual units starts
  * (`TreeSkeleton.set_branch_units`), which is where its leaves are.
  *
+ * The simulation runs for the tree's age: `ShootGrowthConfig.age`, or as long as the framework took to grow if that is
+ * longer. A carrier that stops growing before then grows on from its tip, and its extension is written onto it, so a
+ * tree grown from a seed leader is one stem from the ground up.
+ *
  * The wood thickens with what it carries season by season during the simulation (`ShootGirth`): the twigs keep the
  * radii it gave them, and the carriers and the framework above them are thickened in `skeleton`.
  *

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

@@ -1 +1 @@
-{"version":3,"file":"tree_skeleton_grow_shoots.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/skeleton/tree_skeleton_grow_shoots.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;GAcG;AACH,oDAHW,OAAO,mBAAmB,EAAE,YAAY,WACxC,OAAO,gCAAgC,EAAE,iBAAiB,QAwFpE"}
+{"version":3,"file":"tree_skeleton_grow_shoots.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/skeleton/tree_skeleton_grow_shoots.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;;;;GAkBG;AACH,oDAHW,OAAO,mBAAmB,EAAE,YAAY,WACxC,OAAO,gCAAgC,EAAE,iBAAiB,QAoGpE"}

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

@@ -1,7 +1,7 @@
 import { assert } from "../../../core/assert.js";
 import { seededRandom } from "../../../core/math/random/seededRandom.js";
 import { shoot_sample_unit_length } from "./shoot_demography.js";
-import { shoot_locate_on_chain, shoot_perpendicular3 } from "./shoot_geometry.js";
+import { shoot_framework_buried, shoot_locate_on_chain, shoot_perpendicular3 } from "./shoot_geometry.js";
 import { shoot_systems_simulate } from "./shoot_systems_simulate.js";
 import { spine_frame_double_reflection } from "./spine_frame_double_reflection.js";
 
@@ -16,6 +16,10 @@ const SCRATCH_RMF = new Float64Array(6);
  * the wind rig treat the system as one twig layer. Every carrier and axis records where each of its annual units starts
  * (`TreeSkeleton.set_branch_units`), which is where its leaves are.
  *
+ * The simulation runs for the tree's age: `ShootGrowthConfig.age`, or as long as the framework took to grow if that is
+ * longer. A carrier that stops growing before then grows on from its tip, and its extension is written onto it, so a
+ * tree grown from a seed leader is one stem from the ground up.
+ *
  * The wood thickens with what it carries season by season during the simulation (`ShootGirth`): the twigs keep the
  * radii it gave them, and the carriers and the framework above them are thickened in `skeleton`.
  *
@@ -36,14 +40,15 @@ export function tree_skeleton_grow_shoots(skeleton, species) {
     const ages = framework_ages(skeleton, species.shoot_growth.leader_growth);
     let years = 1;
     for (let b = 0; b < framework_count; b++) years = Math.max(years, Math.round(ages[b]));
+    const seasons = Math.max(years, species.shoot_growth.age);
 
     // The carriers, laid out in as many annual units as they are years old, each about its share of their length
     /** @type {import("./shoot_systems_simulate.js").ShootCarrier[]} */
     const carriers = [];
     for (let r = 0; r < rules.length; r++) {
         const rule = rules[r];
-        assert.ok(rule.source >= 0 && rule.source < rule.target && rule.target < species.branches.length,
-            'shoot rule must satisfy 0 <= source < target < branches.length');
+        assert.ok(rule.source >= 0 && rule.target.every(t => rule.source < t && t < species.branches.length),
+            'shoot rule must satisfy 0 <= source < target < branches.length for every target');
         if (rule.zones.some(z => z.short.some(p => p > 0))) {
             assert.ok(rule.source < rule.short_target && rule.short_target < species.branches.length,
                 'a shoot rule that grows short shoots must satisfy source < short_target < branches.length');
@@ -71,8 +76,6 @@ export function tree_skeleton_grow_shoots(skeleton, species) {
                 arc -= units[k];
                 starts[k] = arc;
             }
-            skeleton.set_branch_units(carrier, Array.from(starts, (a) => a / length));
-
             const carrier_nodes = nodes.slice();
             const carrier_edges = edges.slice();
             const points = new Float64Array((units.length + 1) * 3);
@@ -95,7 +98,15 @@ export function tree_skeleton_grow_shoots(skeleton, species) {
         return;
     }
 
-    const axes = shoot_systems_simulate(skeleton, species, carriers, years, rng);
+    const axes = shoot_systems_simulate(skeleton, species, carriers, seasons, rng);
+
+    // a carrier's extension becomes the rest of the carrier, before anything is located along it
+    for (const axis of axes) {
+        if (axis.extends) extend_carrier(skeleton, carriers[axis.system], axis);
+    }
+    for (const c of carriers) {
+        skeleton.set_branch_units(c.carrier, Array.from(c.starts, (a) => a / c.length));
+    }
 
     // a short shoot grows millimetres a year and bears no laterals: one segment for all its years
     for (const axis of axes) {
@@ -110,6 +121,11 @@ export function tree_skeleton_grow_shoots(skeleton, species) {
     }
 
     write_axes(skeleton, carriers, axes);
+
+    // framework wood its parent's thickening has grown over is dead
+    for (let b = 0; b < framework_count; b++) {
+        if (!skeleton.branch_dead[b] && shoot_framework_buried(skeleton, b)) skeleton.branch_dead[b] = 1;
+    }
 }
 
 /**
@@ -140,6 +156,81 @@ function framework_ages(skeleton, leader_growth) {
 
 
 
+/**
+ * Writes carrier `c`'s extension onto the end of it: a node at each of its unit boundaries with its radii, a segment a
+ * unit. The carrier's nodes, the framework branches it carries and its scars keep their place along it as it grows
+ * longer; its record of units gains the extension's. The extension's segments are left in `axis.edges`.
+ *
+ * @param {import("./TreeSkeleton.js").TreeSkeleton} skeleton
+ * @param {import("./shoot_systems_simulate.js").ShootCarrier} c
+ * @param {import("./shoot_systems_simulate.js").ShootAxis & {edges?: number[]}} axis
+ */
+function extend_carrier(skeleton, c, axis) {
+    const b = c.carrier;
+    const old_length = c.length;
+    let added = 0;
+    for (let k = 0; k < axis.units.length; k++) added += axis.units[k];
+    const length = old_length + added;
+    const scale = old_length / length;
+
+    for (let i = 0; i < c.nodes.length; i++) {
+        skeleton.node_write_t_norm(c.nodes[i], skeleton.node_t_norm(c.nodes[i]) * scale);
+    }
+    for (let child = 0; child < skeleton.branch_count; child++) {
+        if (skeleton.branch_parent[child] === b) skeleton.branch_parent_attach_t[child] *= scale;
+    }
+    for (let i = 0; i < skeleton.scar_count; i++) {
+        if (skeleton.scar_branch[i] === b) skeleton.scar_data[i * 5] *= scale;
+    }
+
+    const level = skeleton.branch_level[b];
+    const parent_branch = skeleton.branch_parent[b];
+    const phase = skeleton.branch_phase_hash[b];
+    let prev_v = skeleton.branch_tip_vertex[b];
+    const arc_base = skeleton.node_arc_s(prev_v);
+    skeleton.node_read_frame_r(SCRATCH_R, 0, prev_v);
+    let rx = SCRATCH_R[0], ry = SCRATCH_R[1], rz = SCRATCH_R[2];
+    skeleton.node_read_tangent(SCRATCH_P, 0, prev_v);
+    let tx = SCRATCH_P[0], ty = SCRATCH_P[1], tz = SCRATCH_P[2];
+    const pts = axis.points;
+    let px = pts[0], py = pts[1], pz = pts[2];
+    const starts = Array.from(c.starts);
+    const units = c.units.slice();
+    const edges = [];
+    let arc = old_length;
+    for (let k = 0; k < axis.units.length; k++) {
+        const len = axis.units[k];
+        const nx = pts[(k + 1) * 3], ny = pts[(k + 1) * 3 + 1], nz = pts[(k + 1) * 3 + 2];
+        const d = Math.max(1e-9, Math.hypot(nx - px, ny - py, nz - pz));
+        const ntx = (nx - px) / d, nty = (ny - py) / d, ntz = (nz - pz) / d;
+        spine_frame_double_reflection(SCRATCH_RMF, 0, px, py, pz, tx, ty, tz, rx, ry, rz, nx, ny, nz, ntx, nty, ntz);
+        rx = SCRATCH_RMF[0];
+        ry = SCRATCH_RMF[1];
+        rz = SCRATCH_RMF[2];
+        tx = ntx;
+        ty = nty;
+        tz = ntz;
+        starts.push(arc);
+        units.push(len);
+        const t_prev = arc / length;
+        arc += len;
+        const curr_v = skeleton.add_node(nx, ny, nz, tx, ty, tz, rx, ry, rz, axis.radii[k + 1], b, level, parent_branch, arc / length, arc_base + arc - old_length, phase);
+        edges.push(skeleton.add_segment(prev_v, curr_v, tx * len, ty * len, tz * len, tx * len, ty * len, tz * len, len, t_prev));
+        c.nodes.push(curr_v);
+        c.edges.push(edges[k]);
+        prev_v = curr_v;
+        px = nx;
+        py = ny;
+        pz = nz;
+    }
+    skeleton.branch_tip_vertex[b] = prev_v;
+    skeleton.branch_length[b] = length;
+    c.length = length;
+    c.units = units;
+    c.starts = Float64Array.from(starts);
+    axis.edges = edges;
+}
+
 /**
  * Writes every axis as a branch: nodes at its unit boundaries with its radii, a segment a unit,
  * hanging from its mother's unit (or its carrier) where it grew, and its unit record.
@@ -154,6 +245,11 @@ function write_axes(skeleton, carriers, axes) {
     for (let m = 0; m < axes.length; m++) {
         const axis = axes[m];
         const c = carriers[axis.system];
+        if (axis.extends) {
+            written_branch[m] = c.carrier;
+            written_edges[m] = axis.edges;
+            continue;
+        }
 
         let parent_branch;
         let anchor_edge;

package/src/shade/descriptor/binding/BindGroupLayoutEntry.js

@@ -1,7 +1,7 @@
 import { assert } from "../../../core/assert.js";
 import { hash_mix3 } from "../../../core/math/hash/hash_mix3.js";
 import { optional_clone } from "../../../core/model/object/optional_clone.js";
-import { optional_equality } from "../../../core/model/object/optional_equality.js";
+import { objectsEqual } from "../../../core/function/objectsEqual.js";
 import { optional_hash } from "../../../core/model/object/optional_hash.js";
 import { BufferBindingLayout } from "./BufferBindingLayout.js";
 import { ExternalTextureBindingLayout } from "./ExternalTextureBindingLayout.js";
@@ -170,11 +170,11 @@ export class BindGroupLayoutEntry {
 
         return this.binding === other.binding
             && this.visibility === other.visibility
-            && optional_equality(this.buffer, other.buffer)
-            && optional_equality(this.sampler, other.sampler)
-            && optional_equality(this.texture, other.texture)
-            && optional_equality(this.storageTexture, other.storageTexture)
-            && optional_equality(this.externalTexture, other.externalTexture)
+            && objectsEqual(this.buffer, other.buffer)
+            && objectsEqual(this.sampler, other.sampler)
+            && objectsEqual(this.texture, other.texture)
+            && objectsEqual(this.storageTexture, other.storageTexture)
+            && objectsEqual(this.externalTexture, other.externalTexture)
             ;
 
     }

package/src/shade/descriptor/pipeline/render/ColorTargetState.js

@@ -2,7 +2,7 @@ import { assert } from "../../../../core/assert.js";
 import { hash_mix3 } from "../../../../core/math/hash/hash_mix3.js";
 import { computeStringHash } from "../../../../core/primitives/strings/computeStringHash.js";
 import { optional_clone } from "../../../../core/model/object/optional_clone.js";
-import { optional_equality } from "../../../../core/model/object/optional_equality.js";
+import { objectsEqual } from "../../../../core/function/objectsEqual.js";
 import { optional_hash } from "../../../../core/model/object/optional_hash.js";
 import {
     gpu_texture_format_channel_bit_count
@@ -110,7 +110,7 @@ export class ColorTargetState {
     equals(other) {
         return this.format === other.format
             && this.writeMask === other.writeMask
-            && optional_equality(this.blend, other.blend);
+            && objectsEqual(this.blend, other.blend);
     }
 
     /**

package/src/shade/descriptor/pipeline/render/RenderPipelineDescriptor.js

@@ -2,7 +2,7 @@ import { assert } from "../../../../core/assert.js";
 import { hash_mix2 } from "../../../../core/math/hash/hash_mix2.js";
 import { hash_mix3 } from "../../../../core/math/hash/hash_mix3.js";
 import { optional_clone } from "../../../../core/model/object/optional_clone.js";
-import { optional_equality } from "../../../../core/model/object/optional_equality.js";
+import { objectsEqual } from "../../../../core/function/objectsEqual.js";
 import { optional_hash } from "../../../../core/model/object/optional_hash.js";
 import { PipelineDescriptorBase } from "../PipelineDescriptorBase.js";
 import { DepthStencilState } from "./DepthStencilState.js";
@@ -112,7 +112,7 @@ export class RenderPipelineDescriptor extends PipelineDescriptorBase {
             return false;
         }
 
-        if (!optional_equality(this.depthStencil, other.depthStencil)) {
+        if (!objectsEqual(this.depthStencil, other.depthStencil)) {
             return false;
         }
 
@@ -120,7 +120,7 @@ export class RenderPipelineDescriptor extends PipelineDescriptorBase {
             return false;
         }
 
-        if (!optional_equality(this.fragment, other.fragment)) {
+        if (!objectsEqual(this.fragment, other.fragment)) {
             return false;
         }