@woosh/meep-engine 3.58.0 → 3.60.0

package/src/generation/foliage/material/tree_cluster_atlas.js

@@ -0,0 +1,37 @@
+import { tree_cluster_cards } from "../mesh/tree_cluster_cards.js";
+import { tree_cluster_representatives } from "../mesh/tree_cluster_representatives.js";
+import { tree_clusters } from "../mesh/tree_clusters.js";
+import { tree_mesh_compute_branch_rings } from "../mesh/tree_mesh_build_bark.js";
+import { foliage_material_from_samplers } from "./foliage_material_from_samplers.js";
+import { foliage_tile_layout } from "./foliage_tile.js";
+import { tree_cluster_bake } from "./tree_cluster_bake.js";
+
+/**
+ * The cluster cards of `skeleton` at each of `lods`' errors, all drawn with a few cuts' tiles in one atlas, no larger
+ * than `budget` (`tree_cluster_representatives`), baked from the leaves and twigs those cuts grew (`tree_cluster_bake`).
+ * A tree's own LODs are cut this way, and so are a species' prototypes.
+ *
+ * @param {import("../skeleton/TreeSkeleton.js").TreeSkeleton} skeleton
+ * @param {import("../config/TreeSpeciesConfig.js").TreeSpeciesConfig} species
+ * @param {import("../mesh/foliage_collect_attachments.js").FoliageAttachmentSet} attachments
+ * @param {import("../../../shade/renderer/geometry/Geometry.js").Geometry} leaves every leaf's card, in attachment order
+ * @param {import("../config/TreeLODConfig.js").TreeLODConfig[]} lods finest first
+ * @param {import("../../../shade/renderer/material/StandardShadeMaterial.js").StandardShadeMaterial} leaf_material the
+ *        leaves' material, whose textures the cuts are baked from
+ * @param {number} budget bytes of atlas, its maps' base levels
+ * @param {Map<number, ReturnType<typeof tree_mesh_compute_branch_rings>>} [planned] the bark's rings the caller has
+ *        already planned, by error: taken rather than planned again
+ * @returns {{lods: Array<{clusters: import("../mesh/tree_clusters.js").TreeCluster[], cards: import("../mesh/tree_cluster_cards.js").TreeClusterCard[], error: number}>, representatives: *, bake: import("./tree_cluster_bake.js").TreeClusterBake, material: import("../../../shade/renderer/material/StandardShadeMaterial.js").StandardShadeMaterial}}
+ */
+export function tree_cluster_atlas(skeleton, species, attachments, leaves, lods, leaf_material, budget, planned = new Map()) {
+    const cut = lods.map((lod) => {
+        const clusters = tree_clusters(skeleton, attachments, planned.get(lod.error) ?? tree_mesh_compute_branch_rings(skeleton, species, lod));
+        return { clusters, cards: tree_cluster_cards(skeleton, attachments, leaves, clusters), error: lod.error };
+    });
+    const tiles = foliage_tile_layout(species);
+    const representatives = tree_cluster_representatives(skeleton, attachments, leaves, cut, tiles.texel,
+        tiles.legible_texel, budget);
+    const bake = tree_cluster_bake(skeleton, species, representatives.cards, attachments, leaves, leaf_material, representatives.texels);
+    const material = foliage_material_from_samplers(bake.albedo, bake.normal, bake.orm, "foliage_clusters");
+    return { lods: cut, representatives, bake, material };
+}

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

@@ -158,8 +158,8 @@ export function foliage_collect_attachments(skeleton, config = new TreeSpeciesCo
 	const eligible_branches = [];
 	let total_count = 0;
 	for (let b = 0; b < skeleton.branch_count; b++) {
-		// dead branches carry no leaves
-		if (skeleton.branch_dead[b]) continue;
+		// dead branches carry no leaves; a prototype draws its instance's
+		if (skeleton.branch_dead[b] || skeleton.branch_instance[b] >= 0) continue;
 		const generator = skeleton.branch_generator[b];
 		let chain = null;
 

package/src/generation/foliage/mesh/foliage_scale_spread.d.ts

@@ -0,0 +1,14 @@
+/**
+ * How far a tree's leaves spread in size about their median: the 10th and 90th percentiles of their `scales` over the
+ * 50th. A leaf drawn magnified by a ratio within `[low, high]` is one the tree grows; the representatives draw cuts
+ * within it (`tree_cluster_representatives`), and a species' prototypes are scaled within it (`tree_shoot_prototypes`).
+ *
+ * @param {ArrayLike<number>} scales each leaf's size multiplier (`FoliageAttachmentSet.scales`)
+ * @param {number} count how many of `scales` are leaves, at least 1
+ * @returns {{low: number, high: number}} p10 / p50 and p90 / p50
+ */
+export function foliage_scale_spread(scales: ArrayLike<number>, count: number): {
+    low: number;
+    high: number;
+};
+//# sourceMappingURL=foliage_scale_spread.d.ts.map

package/src/generation/foliage/mesh/foliage_scale_spread.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"foliage_scale_spread.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/mesh/foliage_scale_spread.js"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,6CAJW,UAAU,MAAM,CAAC,SACjB,MAAM,GACJ;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,CAOvC"}

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

@@ -0,0 +1,15 @@
+/**
+ * How far a tree's leaves spread in size about their median: the 10th and 90th percentiles of their `scales` over the
+ * 50th. A leaf drawn magnified by a ratio within `[low, high]` is one the tree grows; the representatives draw cuts
+ * within it (`tree_cluster_representatives`), and a species' prototypes are scaled within it (`tree_shoot_prototypes`).
+ *
+ * @param {ArrayLike<number>} scales each leaf's size multiplier (`FoliageAttachmentSet.scales`)
+ * @param {number} count how many of `scales` are leaves, at least 1
+ * @returns {{low: number, high: number}} p10 / p50 and p90 / p50
+ */
+export function foliage_scale_spread(scales, count) {
+    const sorted = Float32Array.from({ length: count }, (_, i) => scales[i]).sort();
+    const percentile = (p) => sorted[Math.min(count - 1, Math.floor(p * count))];
+    const median = percentile(0.5);
+    return { low: percentile(0.1) / median, high: percentile(0.9) / median };
+}

package/src/generation/foliage/mesh/tree_cluster_representatives.d.ts

@@ -22,18 +22,19 @@
  * than `budget` bytes of atlas hold.
  *
  * - **Texel.** LOD0, seen from any distance, is drawn at the finest texel the budget affords for the whole cover: the
- *   leaf material's own (`fine_texel`, as sharp as the leaf), coarsened by halves while the cover does not fit, but
- *   never past `legible_texel`, the coarsest that still tells the leaf from another. A coarser LOD is seen no nearer
- *   than where the LOD before it is drawn to a pixel, so its texel is that LOD's error, or LOD0's if finer. A cut uses
- *   only representatives at its LOD's texel or finer.
+ *   leaf material's own (`fine_texel`, as sharp as the leaf), coarsened by halves while the cover does not fit, to
+ *   `legible_texel`, the coarsest that still tells the leaf from another, and past it where even that does not fit
+ *   (the conifers' and the shrub's: a pine's cuts are whole boughs). A blurred leaf is still the tree's; a tile drawn
+ *   at a size its leaves do not grow to is not, its twigs as thick as boughs. A coarser LOD is seen no nearer than
+ *   where the LOD before it is drawn to a pixel, so its texel is that LOD's error, or LOD0's if finer. A cut uses only
+ *   representatives at its LOD's texel or finer.
  * - **Choice.** The fewest that draw every cut at a size the tree's own leaves grow to: a cut drawn with a
  *   representative magnifies its leaves by their size ratio, and the tree's leaves already span the 10th to the 90th
  *   percentile of `attachments.scales` about their median, so within that a magnified leaf is one the tree grows.
  *   Greedily, the cut that draws the most cuts not yet drawn, the least unlike them (magnification, leaf coverage,
  *   where it hangs) where several do, while the packed atlas fits `budget`. Past that, another tile adds only
  *   variety the tree already shows. The first is chosen whatever it costs: a tree with leaves draws them.
- * - **Match.** Each cut is drawn with the least unlike of those that draw it at a size the tree grows, or of all when
- *   the budget ran out first.
+ * - **Match.** Each cut is drawn with the least unlike of those that draw it at a size the tree grows.
  * - **Placement.** A cut draws its representative on its own plane, as large as it draws (its leaves' area and its
  *   twigs', so the crown keeps its leaf area and its density), hanging where it hangs, turned so that each runs out
  *   from where it hangs the same way.
@@ -43,7 +44,7 @@
  * @param {import("../../../shade/renderer/geometry/Geometry.js").Geometry} leaves every leaf's card, in attachment order
  * @param {TreeClusterLOD[]} lods finest first
  * @param {number} fine_texel m, the leaf material's own (`FoliageTileLayout.texel`)
- * @param {number} legible_texel m, the coarsest LOD0 is drawn at (`FoliageTileLayout.legible_texel`)
+ * @param {number} legible_texel m, the coarsest LOD0 is drawn at while its cover fits (`FoliageTileLayout.legible_texel`)
  * @param {number} budget bytes of atlas, its maps' base levels
  * @returns {TreeClusterRepresentatives}
  */

package/src/generation/foliage/mesh/tree_cluster_representatives.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tree_cluster_representatives.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/mesh/tree_cluster_representatives.js"],"names":[],"mappings":"AA2CA;;;;;;;GAOG;AAEH;;;;;;;;;;GAUG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,uDATW,OAAO,6BAA6B,EAAE,YAAY,eAClD,OAAO,kCAAkC,EAAE,oBAAoB,UAC/D,OAAO,8CAA8C,EAAE,QAAQ,QAC/D,cAAc,EAAE,cAChB,MAAM,iBACN,MAAM,UACN,MAAM,GACJ,0BAA0B,CAetC;;;;;SAxFa,MAAM;;;;UACN,MAAM;;;;;UACN,MAAM;cAEN,MAAM;;;;cACN,MAAM;;;;iBACN,MAAM;;;;YACN,MAAM;YACN,MAAM;;;;WACN,MAAM;;;;;;cAmBN,OAAO,oBAAoB,EAAE,WAAW,EAAE;WAC1C,OAAO,yBAAyB,EAAE,eAAe,EAAE;;;;WACnD,MAAM;;;;;;;;;WAON,OAAO,yBAAyB,EAAE,eAAe,EAAE;;;;YACnD,YAAY;;;;aACZ,MAAM,EAAE,EAAE;;;;;;gBACV,MAAM;QAAC,GAAG,EAAE,UAAU,CAAC;QAAC,MAAM,EAAE,YAAY,CAAA;KAAC,CAAC"}
+{"version":3,"file":"tree_cluster_representatives.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/mesh/tree_cluster_representatives.js"],"names":[],"mappings":"AA4CA;;;;;;;GAOG;AAEH;;;;;;;;;;GAUG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,uDATW,OAAO,6BAA6B,EAAE,YAAY,eAClD,OAAO,kCAAkC,EAAE,oBAAoB,UAC/D,OAAO,8CAA8C,EAAE,QAAQ,QAC/D,cAAc,EAAE,cAChB,MAAM,iBACN,MAAM,UACN,MAAM,GACJ,0BAA0B,CActC;;;;;SAxFa,MAAM;;;;UACN,MAAM;;;;;UACN,MAAM;cAEN,MAAM;;;;cACN,MAAM;;;;iBACN,MAAM;;;;YACN,MAAM;YACN,MAAM;;;;WACN,MAAM;;;;;;cAmBN,OAAO,oBAAoB,EAAE,WAAW,EAAE;WAC1C,OAAO,yBAAyB,EAAE,eAAe,EAAE;;;;WACnD,MAAM;;;;;;;;;WAON,OAAO,yBAAyB,EAAE,eAAe,EAAE;;;;YACnD,YAAY;;;;aACZ,MAAM,EAAE,EAAE;;;;;;gBACV,MAAM;QAAC,GAAG,EAAE,UAAU,CAAC;QAAC,MAAM,EAAE,YAAY,CAAA;KAAC,CAAC"}

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

@@ -2,6 +2,7 @@ import { assert } from "../../../core/assert.js";
 import { tree_cluster_atlas_pack } from "../material/tree_cluster_atlas_pack.js";
 import { tree_cluster_press } from "../material/tree_cluster_press.js";
 import { tree_cluster_tiles } from "../material/tree_cluster_tiles.js";
+import { foliage_scale_spread } from "./foliage_scale_spread.js";
 
 /**
  * Bytes a texel of the cluster atlas costs, its maps' base levels: albedo RGBA8, normal two channels, ORM RGBA8
@@ -67,18 +68,19 @@ function cut_distance(a, b) {
  * than `budget` bytes of atlas hold.
  *
  * - **Texel.** LOD0, seen from any distance, is drawn at the finest texel the budget affords for the whole cover: the
- *   leaf material's own (`fine_texel`, as sharp as the leaf), coarsened by halves while the cover does not fit, but
- *   never past `legible_texel`, the coarsest that still tells the leaf from another. A coarser LOD is seen no nearer
- *   than where the LOD before it is drawn to a pixel, so its texel is that LOD's error, or LOD0's if finer. A cut uses
- *   only representatives at its LOD's texel or finer.
+ *   leaf material's own (`fine_texel`, as sharp as the leaf), coarsened by halves while the cover does not fit, to
+ *   `legible_texel`, the coarsest that still tells the leaf from another, and past it where even that does not fit
+ *   (the conifers' and the shrub's: a pine's cuts are whole boughs). A blurred leaf is still the tree's; a tile drawn
+ *   at a size its leaves do not grow to is not, its twigs as thick as boughs. A coarser LOD is seen no nearer than
+ *   where the LOD before it is drawn to a pixel, so its texel is that LOD's error, or LOD0's if finer. A cut uses only
+ *   representatives at its LOD's texel or finer.
  * - **Choice.** The fewest that draw every cut at a size the tree's own leaves grow to: a cut drawn with a
  *   representative magnifies its leaves by their size ratio, and the tree's leaves already span the 10th to the 90th
  *   percentile of `attachments.scales` about their median, so within that a magnified leaf is one the tree grows.
  *   Greedily, the cut that draws the most cuts not yet drawn, the least unlike them (magnification, leaf coverage,
  *   where it hangs) where several do, while the packed atlas fits `budget`. Past that, another tile adds only
  *   variety the tree already shows. The first is chosen whatever it costs: a tree with leaves draws them.
- * - **Match.** Each cut is drawn with the least unlike of those that draw it at a size the tree grows, or of all when
- *   the budget ran out first.
+ * - **Match.** Each cut is drawn with the least unlike of those that draw it at a size the tree grows.
  * - **Placement.** A cut draws its representative on its own plane, as large as it draws (its leaves' area and its
  *   twigs', so the crown keeps its leaf area and its density), hanging where it hangs, turned so that each runs out
  *   from where it hangs the same way.
@@ -88,7 +90,7 @@ function cut_distance(a, b) {
  * @param {import("../../../shade/renderer/geometry/Geometry.js").Geometry} leaves every leaf's card, in attachment order
  * @param {TreeClusterLOD[]} lods finest first
  * @param {number} fine_texel m, the leaf material's own (`FoliageTileLayout.texel`)
- * @param {number} legible_texel m, the coarsest LOD0 is drawn at (`FoliageTileLayout.legible_texel`)
+ * @param {number} legible_texel m, the coarsest LOD0 is drawn at while its cover fits (`FoliageTileLayout.legible_texel`)
  * @param {number} budget bytes of atlas, its maps' base levels
  * @returns {TreeClusterRepresentatives}
  */
@@ -99,19 +101,18 @@ export function tree_cluster_representatives(skeleton, attachments, leaves, lods
 
     // every cut's leaves pressed onto it, whatever the texel
     const pressed_lods = lods.map(lod => tree_cluster_press(leaves, attachments, lod.cards));
-    let chosen;
-    for (let texel = Math.min(fine_texel, legible_texel); ; texel = Math.min(2 * texel, legible_texel)) {
-        chosen = choose(skeleton, attachments, leaves, lods, pressed_lods, texel, budget);
-        if (chosen.complete || texel >= legible_texel) break;
+    // Ends: a cut's size is never under a texel, so once a texel is as large as every cut, one tile draws them all
+    for (let texel = Math.min(fine_texel, legible_texel); ; texel = texel < legible_texel ? Math.min(2 * texel, legible_texel) : 2 * texel) {
+        const representatives = choose(skeleton, attachments, leaves, lods, pressed_lods, texel, budget);
+        if (representatives !== null) return representatives;
     }
-    return chosen.representatives;
 }
 
 /**
- * The representatives at LOD0's texel `leaf_texel` (`tree_cluster_representatives`), and whether they draw every cut
- * at a size the tree grows.
+ * The representatives at LOD0's texel `leaf_texel` (`tree_cluster_representatives`), or `null` when the atlas cannot
+ * hold tiles that draw every cut at a size the tree grows.
  *
- * @returns {{representatives: TreeClusterRepresentatives, complete: boolean}}
+ * @returns {TreeClusterRepresentatives|null}
  */
 function choose(skeleton, attachments, leaves, lods, pressed_lods, leaf_texel, budget) {
 
@@ -183,10 +184,9 @@ function choose(skeleton, attachments, leaves, lods, pressed_lods, leaf_texel, b
     }
 
     // ---- the fewest representatives that draw every cut at a size the tree's own leaves grow to, while the atlas fits
-    const sorted_scales = Float32Array.from(attachments.scales).sort();
-    const percentile = (p) => sorted_scales[Math.min(sorted_scales.length - 1, Math.floor(p * sorted_scales.length))];
-    const shrink = Math.log(percentile(0.1) / percentile(0.5));
-    const grow = Math.log(percentile(0.9) / percentile(0.5));
+    const spread = foliage_scale_spread(attachments.scales, attachments.scales.length);
+    const shrink = Math.log(spread.low);
+    const grow = Math.log(spread.high);
     // whether representative `r` draws cut `c` as the tree would grow it: no finer LOD's cut, its leaves magnified
     // within their own spread
     const draws = (c, r) => {
@@ -207,22 +207,70 @@ function choose(skeleton, attachments, leaves, lods, pressed_lods, leaf_texel, b
     for (let c = 0; c < lod0_end; c++) {
         if (shapes[c].bytes <= budget) affordable = true;
     }
+    // How many cuts not yet drawn each would draw: those of its LOD or coarser, their sizes within its window. Cuts
+    // ordered by size, one Fenwick tree a LOD over that order holds those not yet drawn; a window is a range of it.
+    const by_size = Int32Array.from({ length: n }, (_, i) => i).sort((a, b) => shapes[a].log_size - shapes[b].log_size || a - b);
+    const rank = new Int32Array(n);
+    for (let i = 0; i < n; i++) rank[by_size[i]] = i;
+    const undrawn_of_lod = lods.map(() => new Int32Array(n + 1));
+    const fenwick_add = (tree, i, v) => {
+        for (let j = i + 1; j <= n; j += j & -j) tree[j] += v;
+    };
+    const fenwick_sum = (tree, end) => {
+        let s = 0;
+        for (let j = end; j > 0; j -= j & -j) s += tree[j];
+        return s;
+    };
+    for (let c = 0; c < n; c++) fenwick_add(undrawn_of_lod[shapes[c].lod], rank[c], 1);
+    // the first rank, in size order, whose cut is magnified from `log_size` by at least `m` (or past it, `past`)
+    const first_rank = (log_size, m, past) => {
+        let lo = 0, hi = n;
+        while (lo < hi) {
+            const mid = (lo + hi) >> 1;
+            const d = shapes[by_size[mid]].log_size - log_size;
+            if (past ? d > m : d >= m) hi = mid;
+            else lo = mid + 1;
+        }
+        return lo;
+    };
+    const counts = new Int32Array(n);
+    const window = new Int32Array(n);
     while (undrawn > 0) {
         // the one that draws the most cuts not yet drawn, the least unlike them where several do
-        let pick = -1, pick_count = 0, pick_unlike = Infinity;
+        let pick_count = 0;
         for (let r = 0; r < n; r++) {
+            counts[r] = 0;
             if (taken[r]) continue;
             if (chosen.length === 0 ? affordable && shapes[r].bytes > budget : spent + shapes[r].bytes > budget) continue;
-            let count = 0, unlike = 0;
-            for (let c = lod_first[shapes[r].lod]; c < n; c++) {
-                if (drawn[c] || !draws(c, r)) continue;
-                count++;
-                unlike += cut_distance(shapes[c], shapes[r]);
+            const s = shapes[r];
+            const from = first_rank(s.log_size, shrink, false);
+            const to = first_rank(s.log_size, grow, true);
+            let count = 0;
+            for (let k = s.lod; k < lods.length; k++) {
+                count += fenwick_sum(undrawn_of_lod[k], to) - fenwick_sum(undrawn_of_lod[k], from);
             }
-            if (count > pick_count || (count === pick_count && count > 0 && unlike < pick_unlike)) {
-                pick = r;
-                pick_count = count;
-                pick_unlike = unlike;
+            counts[r] = count;
+            if (count > pick_count) pick_count = count;
+        }
+        let pick = -1, pick_unlike = Infinity;
+        if (pick_count > 0) {
+            for (let r = 0; r < n; r++) {
+                if (counts[r] !== pick_count) continue;
+                // the cuts it draws, from its window, summed in the order of the cuts
+                const s = shapes[r];
+                const to = first_rank(s.log_size, grow, true);
+                let w = 0;
+                for (let i = first_rank(s.log_size, shrink, false); i < to; i++) {
+                    const c = by_size[i];
+                    if (!drawn[c] && shapes[c].lod >= s.lod) window[w++] = c;
+                }
+                window.subarray(0, w).sort();
+                let unlike = 0;
+                for (let i = 0; i < w; i++) unlike += cut_distance(shapes[window[i]], s);
+                if (unlike < pick_unlike) {
+                    pick = r;
+                    pick_unlike = unlike;
+                }
             }
         }
         if (pick < 0) break;
@@ -243,9 +291,11 @@ function choose(skeleton, attachments, leaves, lods, pressed_lods, leaf_texel, b
             if (!drawn[c] && draws(c, pick)) {
                 drawn[c] = 1;
                 undrawn--;
+                fenwick_add(undrawn_of_lod[shapes[c].lod], rank[c], -1);
             }
         }
     }
+    if (undrawn > 0) return null;
 
     // ---- every cut's nearest, and where it lands
     const placements = [];
@@ -255,18 +305,13 @@ function choose(skeleton, attachments, leaves, lods, pressed_lods, leaf_texel, b
         const frames = new Float64Array(count * 12);
         const tiles = lod_tiles[k];
         for (let i = 0; i < count; i++) {
-            const c = shapes[lod_first[k] + i];
-            // among those that draw it as the tree would grow it, the least unlike; the least unlike of all when none does
-            let r_best = -1, d_best = Infinity;
             const own = lod_first[k] + i;
-            let any_grown = false;
-            for (let r = 0; r < chosen.length; r++) {
-                if (draws(own, chosen[r])) any_grown = true;
-            }
+            const c = shapes[own];
+            // among those that draw it as the tree would grow it, the least unlike
+            let r_best = -1, d_best = Infinity;
             for (let r = 0; r < chosen.length; r++) {
-                const s = shapes[chosen[r]];
-                if (s.lod > k || (any_grown && !draws(own, chosen[r]))) continue;
-                const d = cut_distance(c, s);
+                if (!draws(own, chosen[r])) continue;
+                const d = cut_distance(c, shapes[chosen[r]]);
                 if (d < d_best) {
                     d_best = d;
                     r_best = r;
@@ -305,5 +350,5 @@ function choose(skeleton, attachments, leaves, lods, pressed_lods, leaf_texel, b
         cards.push(lods[s.lod].cards[s.card]);
         sources.push([s.lod, s.card]);
     }
-    return { representatives: { cards, texels, sources, placements }, complete: undrawn === 0 };
+    return { cards, texels, sources, placements };
 }

package/src/generation/foliage/mesh/tree_clusters.d.ts

@@ -3,11 +3,12 @@
  * it, and where it hangs.
  *
  * @typedef {Object} TreeCluster
- * @property {number} branch the drawn branch it hangs from, `-1` when the tree draws no wood at all
+ * @property {number} branch the drawn branch it hangs from, `-1` when its tree draws no wood at all
  * @property {number} t where along that branch, as `t_norm`
+ * @property {number} root the root branch of that tree when `branch` is `-1`, else `-1`
  * @property {number[]} leaves attachment indices of its leaves
  * @property {number[]} wood the undrawn branches it holds
- * @property {Float64Array} position where it hangs: on its branch's drawn bark, or the tree's root
+ * @property {Float64Array} position where it hangs: on its branch's drawn bark, or its tree's root
  * @property {Uint16Array} joints the four skinning joints of that point
  * @property {Float32Array} weights their weights
  */
@@ -20,7 +21,7 @@
  *   one, at their mean place.
  *
  * Every leaf and every undrawn branch belongs to exactly one cluster. A tree whose wood is all thinner than the error
- * is one cluster, hanging from its root.
+ * is one cluster, hanging from its root; so is each tree of a skeleton that holds several (a species' prototypes).
  *
  * @param {import("../skeleton/TreeSkeleton.js").TreeSkeleton} skeleton
  * @param {import("./foliage_collect_attachments.js").FoliageAttachmentSet} attachments
@@ -34,19 +35,38 @@ export function tree_clusters(skeleton: import("../skeleton/TreeSkeleton.js").Tr
     cy: number;
     cz: number;
 }>>): TreeCluster[];
+/**
+ * Where `cluster` hangs, and how the wind carries that point: on its branch's drawn bark at its `t`, skinned as that
+ * bark is there; a whole tree's cut (`branch` -1) from its tree's root.
+ *
+ * @param {import("../skeleton/TreeSkeleton.js").TreeSkeleton} skeleton bound to the rig `rings` were planned with
+ * @param {Map<number, Array<{t_norm: number, cx: number, cy: number, cz: number}>>} rings
+ * @param {ReturnType<typeof tree_skeleton_read_joint_motion>} joint_motion
+ * @param {TreeCluster} cluster its `branch`, `t` and `root` read, its `position`, `joints` and `weights` written
+ */
+export function tree_cluster_hang(skeleton: import("../skeleton/TreeSkeleton.js").TreeSkeleton, rings: Map<number, Array<{
+    t_norm: number;
+    cx: number;
+    cy: number;
+    cz: number;
+}>>, joint_motion: ReturnType<typeof tree_skeleton_read_joint_motion>, cluster: TreeCluster): void;
 /**
  * What one cluster card draws: the wood an LOD's error leaves undrawn where it joins drawn wood, with everything on
  * it, and where it hangs.
  */
 export type TreeCluster = {
     /**
-     * the drawn branch it hangs from, `-1` when the tree draws no wood at all
+     * the drawn branch it hangs from, `-1` when its tree draws no wood at all
      */
     branch: number;
     /**
      * where along that branch, as `t_norm`
      */
     t: number;
+    /**
+     * the root branch of that tree when `branch` is `-1`, else `-1`
+     */
+    root: number;
     /**
      * attachment indices of its leaves
      */
@@ -56,7 +76,7 @@ export type TreeCluster = {
      */
     wood: number[];
     /**
-     * where it hangs: on its branch's drawn bark, or the tree's root
+     * where it hangs: on its branch's drawn bark, or its tree's root
      */
     position: Float64Array;
     /**
@@ -68,4 +88,5 @@ export type TreeCluster = {
      */
     weights: Float32Array;
 };
+import { tree_skeleton_read_joint_motion } from "../skeleton/tree_skeleton_read_joint_motion.js";
 //# sourceMappingURL=tree_clusters.d.ts.map

package/src/generation/foliage/mesh/tree_clusters.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tree_clusters.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/mesh/tree_clusters.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;GAYG;AAEH;;;;;;;;;;;;;;;;GAgBG;AACH,wCANW,OAAO,6BAA6B,EAAE,YAAY,eAClD,OAAO,kCAAkC,EAAE,oBAAoB,SAC/D,IAAI,MAAM,EAAE,MAAM;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAC,CAAC,CAAC,GAEtE,WAAW,EAAE,CAuIzB;;;;;;;;;YA/Ja,MAAM;;;;OACN,MAAM;;;;YACN,MAAM,EAAE;;;;UACR,MAAM,EAAE;;;;cACR,YAAY;;;;YACZ,WAAW;;;;aACX,YAAY"}
+{"version":3,"file":"tree_clusters.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/mesh/tree_clusters.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;GAaG;AAEH;;;;;;;;;;;;;;;;GAgBG;AACH,wCANW,OAAO,6BAA6B,EAAE,YAAY,eAClD,OAAO,kCAAkC,EAAE,oBAAoB,SAC/D,IAAI,MAAM,EAAE,MAAM;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAC,CAAC,CAAC,GAEtE,WAAW,EAAE,CAsGzB;AAED;;;;;;;;GAQG;AACH,4CALW,OAAO,6BAA6B,EAAE,YAAY,SAClD,IAAI,MAAM,EAAE,MAAM;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAC,CAAC,CAAC,gBACxE,WAAW,sCAAsC,CAAC,WAClD,WAAW,QAoCrB;;;;;;;;;YA5Ka,MAAM;;;;OACN,MAAM;;;;UACN,MAAM;;;;YACN,MAAM,EAAE;;;;UACR,MAAM,EAAE;;;;cACR,YAAY;;;;YACZ,WAAW;;;;aACX,YAAY;;gDAnBsB,gDAAgD"}

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

@@ -12,11 +12,12 @@ const SCRATCH_WEIGHTS4 = new Float64Array(4);
  * it, and where it hangs.
  *
  * @typedef {Object} TreeCluster
- * @property {number} branch the drawn branch it hangs from, `-1` when the tree draws no wood at all
+ * @property {number} branch the drawn branch it hangs from, `-1` when its tree draws no wood at all
  * @property {number} t where along that branch, as `t_norm`
+ * @property {number} root the root branch of that tree when `branch` is `-1`, else `-1`
  * @property {number[]} leaves attachment indices of its leaves
  * @property {number[]} wood the undrawn branches it holds
- * @property {Float64Array} position where it hangs: on its branch's drawn bark, or the tree's root
+ * @property {Float64Array} position where it hangs: on its branch's drawn bark, or its tree's root
  * @property {Uint16Array} joints the four skinning joints of that point
  * @property {Float32Array} weights their weights
  */
@@ -30,7 +31,7 @@ const SCRATCH_WEIGHTS4 = new Float64Array(4);
  *   one, at their mean place.
  *
  * Every leaf and every undrawn branch belongs to exactly one cluster. A tree whose wood is all thinner than the error
- * is one cluster, hanging from its root.
+ * is one cluster, hanging from its root; so is each tree of a skeleton that holds several (a species' prototypes).
  *
  * @param {import("../skeleton/TreeSkeleton.js").TreeSkeleton} skeleton
  * @param {import("./foliage_collect_attachments.js").FoliageAttachmentSet} attachments
@@ -58,8 +59,8 @@ export function tree_clusters(skeleton, attachments, rings) {
     // a cut's cluster, by its root; a drawn branch's tip cluster, by the branch
     const of_root = new Map();
     const of_tip = new Map();
-    const make = (branch, t) => {
-        const cluster = { branch, t, leaves: [], wood: [], position: new Float64Array(3), joints: new Uint16Array(4), weights: new Float32Array(4) };
+    const make = (branch, t, root = -1) => {
+        const cluster = { branch, t, root, leaves: [], wood: [], position: new Float64Array(3), joints: new Uint16Array(4), weights: new Float32Array(4) };
         clusters.push(cluster);
         return cluster;
     };
@@ -76,7 +77,7 @@ export function tree_clusters(skeleton, attachments, rings) {
         if (c !== undefined) return c;
         const p = skeleton.branch_parent[r];
         if (p < 0) {
-            c = make(-1, 0);
+            c = make(-1, 0, r);
         } else {
             const t = skeleton.branch_parent_attach_t[r];
             c = t > end_t(p) ? tip_of(p) : make(p, t);
@@ -136,39 +137,51 @@ export function tree_clusters(skeleton, attachments, rings) {
 
     // where each hangs, and how the wind carries that point
     const joint_motion = tree_skeleton_read_joint_motion(skeleton);
-    for (const cluster of clusters) {
-        if (cluster.branch < 0) {
-            const root = skeleton.branch_root_vertex[0];
-            skeleton.node_read_position(SCRATCH_P, 0, root);
-            cluster.position[0] = SCRATCH_P[0];
-            cluster.position[1] = SCRATCH_P[1];
-            cluster.position[2] = SCRATCH_P[2];
-            cluster.joints[0] = skeleton.node_read_joint(root, 0);
-            cluster.weights[0] = 1;
-            continue;
-        }
-        const list = rings.get(cluster.branch);
-        let k = list.length - 2;
-        for (let i = 0; i < list.length - 1; i++) {
-            if (cluster.t <= list[i + 1].t_norm) {
-                k = i;
-                break;
-            }
-        }
-        const ra = list[k];
-        const rb = list[k + 1];
-        const xi = clamp((cluster.t - ra.t_norm) / Math.max(1e-9, rb.t_norm - ra.t_norm), 0, 1);
-        const px = lerp(ra.cx, rb.cx, xi);
-        const py = lerp(ra.cy, rb.cy, xi);
-        const pz = lerp(ra.cz, rb.cz, xi);
-        cluster.position[0] = px;
-        cluster.position[1] = py;
-        cluster.position[2] = pz;
-        interpolate_ring_skin_weights4(SCRATCH_JOINTS4, 0, SCRATCH_WEIGHTS4, 0, ra, rb, xi, joint_motion, px, py, pz);
-        for (let s = 0; s < 4; s++) {
-            cluster.joints[s] = SCRATCH_JOINTS4[s];
-            cluster.weights[s] = SCRATCH_WEIGHTS4[s];
+    for (const cluster of clusters) tree_cluster_hang(skeleton, rings, joint_motion, cluster);
+    return clusters;
+}
+
+/**
+ * Where `cluster` hangs, and how the wind carries that point: on its branch's drawn bark at its `t`, skinned as that
+ * bark is there; a whole tree's cut (`branch` -1) from its tree's root.
+ *
+ * @param {import("../skeleton/TreeSkeleton.js").TreeSkeleton} skeleton bound to the rig `rings` were planned with
+ * @param {Map<number, Array<{t_norm: number, cx: number, cy: number, cz: number}>>} rings
+ * @param {ReturnType<typeof tree_skeleton_read_joint_motion>} joint_motion
+ * @param {TreeCluster} cluster its `branch`, `t` and `root` read, its `position`, `joints` and `weights` written
+ */
+export function tree_cluster_hang(skeleton, rings, joint_motion, cluster) {
+    if (cluster.branch < 0) {
+        // a whole tree's cut hangs from that tree's root
+        const root = skeleton.branch_root_vertex[cluster.root];
+        skeleton.node_read_position(SCRATCH_P, 0, root);
+        cluster.position[0] = SCRATCH_P[0];
+        cluster.position[1] = SCRATCH_P[1];
+        cluster.position[2] = SCRATCH_P[2];
+        cluster.joints[0] = skeleton.node_read_joint(root, 0);
+        cluster.weights[0] = 1;
+        return;
+    }
+    const list = rings.get(cluster.branch);
+    let k = list.length - 2;
+    for (let i = 0; i < list.length - 1; i++) {
+        if (cluster.t <= list[i + 1].t_norm) {
+            k = i;
+            break;
         }
     }
-    return clusters;
+    const ra = list[k];
+    const rb = list[k + 1];
+    const xi = clamp((cluster.t - ra.t_norm) / Math.max(1e-9, rb.t_norm - ra.t_norm), 0, 1);
+    const px = lerp(ra.cx, rb.cx, xi);
+    const py = lerp(ra.cy, rb.cy, xi);
+    const pz = lerp(ra.cz, rb.cz, xi);
+    cluster.position[0] = px;
+    cluster.position[1] = py;
+    cluster.position[2] = pz;
+    interpolate_ring_skin_weights4(SCRATCH_JOINTS4, 0, SCRATCH_WEIGHTS4, 0, ra, rb, xi, joint_motion, px, py, pz);
+    for (let s = 0; s < 4; s++) {
+        cluster.joints[s] = SCRATCH_JOINTS4[s];
+        cluster.weights[s] = SCRATCH_WEIGHTS4[s];
+    }
 }

package/src/generation/foliage/mesh/tree_mesh_build_bark.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tree_mesh_build_bark.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/mesh/tree_mesh_build_bark.js"],"names":[],"mappings":"AAyiBA;;;;;GAKG;AACH,2DAJW,QAAQ,SACR,MAAM,GACJ,WAAW,CAevB;AAED;;;;;;;;;;GAUG;AACH,+CANW,OAAO,6BAA6B,EAAE,YAAY,WAClD,iBAAiB,eACjB,aAAa,QACb,OAAO,8CAA8C,EAAE,QAAQ,yBAC7D,QAAQ,CAqzBpB;AAED;;;;;;;;;;;;;;GAcG;AACH,yDAVW,OAAO,6BAA6B,EAAE,YAAY,WAClD,iBAAiB,eACjB,aAAa,GACX,IAAI,MAAM,EAAE,MAAM;IAC9B,EAAM,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IACvC,CAAK,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAC5D,EAAM,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IACnD,EAAM,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAC/C,CAAC,CAAC,CAQL;yBA74CwB,8CAA8C;kCAOrC,gCAAgC;8BADpC,4BAA4B"}
+{"version":3,"file":"tree_mesh_build_bark.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/mesh/tree_mesh_build_bark.js"],"names":[],"mappings":"AA+iBA;;;;;GAKG;AACH,2DAJW,QAAQ,SACR,MAAM,GACJ,WAAW,CAevB;AAED;;;;;;;;;;GAUG;AACH,+CANW,OAAO,6BAA6B,EAAE,YAAY,WAClD,iBAAiB,eACjB,aAAa,QACb,OAAO,8CAA8C,EAAE,QAAQ,yBAC7D,QAAQ,CAyxBpB;AAED;;;;;;;;;;;;;;GAcG;AACH,yDAVW,OAAO,6BAA6B,EAAE,YAAY,WAClD,iBAAiB,eACjB,aAAa,GACX,IAAI,MAAM,EAAE,MAAM;IAC9B,EAAM,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IACvC,CAAK,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAC5D,EAAM,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IACnD,EAAM,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAC/C,CAAC,CAAC,CAQL;yBAv3CwB,8CAA8C;kCAOrC,gCAAgC;8BADpC,4BAA4B"}