@woosh/meep-engine 3.57.0 → 3.58.0

package/src/generation/foliage/analysis/tree_leaf_area_targets.d.ts

@@ -0,0 +1,66 @@
+/**
+ * The leaf area a measured tree of a preset's species carries at breast-height diameter `dbh_cm` and height
+ * `height_m`: the range over the allometries that hold it, and every allometry's value with whether `dbh_cm` is inside
+ * its sample. `null` for a species with none.
+ *
+ * @param {TreePreset|string} preset
+ * @param {number} dbh_cm
+ * @param {number} height_m
+ * @returns {{low: number, high: number, values: Array<{source: string, leaf_area: number, in_sample: boolean}>}|null}
+ */
+export function tree_expected_leaf_area(preset: TreePreset | string, dbh_cm: number, height_m: number): {
+    low: number;
+    high: number;
+    values: Array<{
+        source: string;
+        leaf_area: number;
+        in_sample: boolean;
+    }>;
+} | null;
+/**
+ * Measured whole-tree leaf area against breast-height diameter, per preset species, from forest-grown samples (no
+ * open-grown allometry was found). Broadleaves are one-sided; the conifers' convention differs between sources, which
+ * is part of the spread. See `CROWN_FULLNESS_BRIEF_2026_10_26.md`.
+ *
+ * - [F17]: Forrester et al. (2017), For. Ecol. Manage. 396: 160-175, Appendix A, Table A.5: `ln LA = ln b0 + b ln d`,
+ *   times the correction factor.
+ * - [M98]: Martin et al. (1998), Can. J. For. Res. 28: 1648-1659, Table 4: `log10 LA = a + b log10 d`, times the
+ *   correction factor.
+ * - [GG15]: Gomez-Garcia & Perez-Rodriguez (2015), Bosque 36: 255-264, eq. 9: leaf mass `0.01369 d²` kg, times the SLA
+ *   of mature Q. robur, 12.85-16.2 m²/kg (F17 Table A.1).
+ * - [R09]: Repola (2009), Silva Fennica 43: 184, eqs. 7 and 15: needle mass, times projected SLA (Scots pine 3.86-5.65
+ *   m²/kg, Bilgili et al. 2020, Dendrobiology 84: 1-11; Norway spruce 3.3-5.0 m²/kg, F17 Table A.1).
+ *
+ * @type {Object<string, LeafAreaAllometry[]>}
+ */
+export const TREE_LEAF_AREA_ALLOMETRY: {
+    [x: string]: LeafAreaAllometry[];
+};
+/**
+ * FIA's ratings of a healthy crown seen from the side: crown density, the share of the crown outline that foliage,
+ * branches and reproductive structures block, and foliage transparency, the skylight through the foliated part
+ * [Randolph 2006, as cited in `CROWN_FILLING_BRIEF_2026_10_26.md`].
+ * @type {{density_min: number, density_max: number, transparency: number}}
+ */
+export const TREE_CROWN_RATING_TARGET: {
+    density_min: number;
+    density_max: number;
+    transparency: number;
+};
+export type LeafAreaAllometry = {
+    /**
+     * citation
+     */
+    source: string;
+    /**
+     * the sample's breast-height diameters (cm)
+     */
+    dbh_min: number;
+    dbh_max: number;
+    /**
+     * m² at a DBH (cm) and height (m)
+     */
+    leaf_area: (arg0: number, arg1: number) => number;
+};
+import { TreePreset } from "../config/TreePreset.js";
+//# sourceMappingURL=tree_leaf_area_targets.d.ts.map

package/src/generation/foliage/analysis/tree_leaf_area_targets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree_leaf_area_targets.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/analysis/tree_leaf_area_targets.js"],"names":[],"mappings":"AAoEA;;;;;;;;;GASG;AACH,gDALW,UAAU,GAAC,MAAM,UACjB,MAAM,YACN,MAAM,GACJ;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,OAAO,CAAA;KAAC,CAAC,CAAA;CAAC,GAAC,IAAI,CAkBpH;AA1ED;;;;;;;;;;;;;;;GAeG;AACH;QAFiB,MAAM,GAAE,iBAAiB,EAAE;EAwB1C;AAEF;;;;;GAKG;AACH,uCAFU;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAC,CAE2B;;;;;YA9DvF,MAAM;;;;aACN,MAAM;aACN,MAAM;;;;sBACG,MAAM,QAAE,MAAM,KAAG,MAAM;;2BAPnB,yBAAyB"}

package/src/generation/foliage/analysis/tree_leaf_area_targets.js

@@ -0,0 +1,95 @@
+import { TreePreset } from "../config/TreePreset.js";
+
+/**
+ * @typedef {Object} LeafAreaAllometry
+ * @property {string} source citation
+ * @property {number} dbh_min the sample's breast-height diameters (cm)
+ * @property {number} dbh_max
+ * @property {function(number, number): number} leaf_area m² at a DBH (cm) and height (m)
+ */
+
+/**
+ * Repola (2009) needle mass (kg) of a tree of diameter `d` (cm) and height `h` (m): `ln y = a + b dS / (dS + k) +
+ * c h / (h + 1)`, `dS = 2 + 1.25 d`, the log bias corrected by half the summed variances [Repola 2009, Silva Fennica 43:
+ * 184].
+ */
+function repola_needles(a, b, k, c, variances, d, h) {
+    const ds = 2 + 1.25 * d;
+    return Math.exp(a + b * ds / (ds + k) + c * h / (h + 1) + 0.5 * variances);
+}
+
+/**
+ * Measured whole-tree leaf area against breast-height diameter, per preset species, from forest-grown samples (no
+ * open-grown allometry was found). Broadleaves are one-sided; the conifers' convention differs between sources, which
+ * is part of the spread. See `CROWN_FULLNESS_BRIEF_2026_10_26.md`.
+ *
+ * - [F17]: Forrester et al. (2017), For. Ecol. Manage. 396: 160-175, Appendix A, Table A.5: `ln LA = ln b0 + b ln d`,
+ *   times the correction factor.
+ * - [M98]: Martin et al. (1998), Can. J. For. Res. 28: 1648-1659, Table 4: `log10 LA = a + b log10 d`, times the
+ *   correction factor.
+ * - [GG15]: Gomez-Garcia & Perez-Rodriguez (2015), Bosque 36: 255-264, eq. 9: leaf mass `0.01369 d²` kg, times the SLA
+ *   of mature Q. robur, 12.85-16.2 m²/kg (F17 Table A.1).
+ * - [R09]: Repola (2009), Silva Fennica 43: 184, eqs. 7 and 15: needle mass, times projected SLA (Scots pine 3.86-5.65
+ *   m²/kg, Bilgili et al. 2020, Dendrobiology 84: 1-11; Norway spruce 3.3-5.0 m²/kg, F17 Table A.1).
+ *
+ * @type {Object<string, LeafAreaAllometry[]>}
+ */
+export const TREE_LEAF_AREA_ALLOMETRY = {
+    [TreePreset.Oak]: [
+        { source: "F17 Quercus robur", dbh_min: 5.9, dbh_max: 67.5, leaf_area: (d) => Math.exp(-1.7839) * Math.pow(d, 2.1375) * 0.966 },
+        { source: "GG15 leaf mass x SLA 12.85", dbh_min: 5, dbh_max: 40, leaf_area: (d) => 0.01369 * d * d * 12.85 },
+        { source: "GG15 leaf mass x SLA 16.2", dbh_min: 5, dbh_max: 40, leaf_area: (d) => 0.01369 * d * d * 16.2 }
+    ],
+    [TreePreset.Pine]: [
+        { source: "F17 Pinus sylvestris", dbh_min: 1, dbh_max: 61.7, leaf_area: (d) => Math.exp(-2.065) * Math.pow(d, 1.746) * 1.0096 },
+        { source: "R09 needles x SLA 3.86", dbh_min: 1.5, dbh_max: 35.8, leaf_area: (d, h) => repola_needles(-6.303, 14.472, 6, -3.976, 0.109 + 0.118, d, h) * 3.86 },
+        { source: "R09 needles x SLA 5.65", dbh_min: 1.5, dbh_max: 35.8, leaf_area: (d, h) => repola_needles(-6.303, 14.472, 6, -3.976, 0.109 + 0.118, d, h) * 5.65 }
+    ],
+    [TreePreset.Maple]: [
+        { source: "M98 Acer rubrum", dbh_min: 6.3, dbh_max: 52.4, leaf_area: (d) => Math.pow(10, -0.494) * Math.pow(d, 1.762) * 1.046 }
+    ],
+    [TreePreset.Spruce]: [
+        { source: "F17 Picea abies", dbh_min: 1, dbh_max: 76.4, leaf_area: (d) => Math.exp(-1.3434) * Math.pow(d, 1.857) * 1.011 },
+        { source: "R09 needles x SLA 3.3", dbh_min: 1.7, dbh_max: 41.7, leaf_area: (d, h) => repola_needles(-2.994, 12.251, 10, -3.415, 0.107 + 0.089, d, h) * 3.3 },
+        { source: "R09 needles x SLA 5.0", dbh_min: 1.7, dbh_max: 41.7, leaf_area: (d, h) => repola_needles(-2.994, 12.251, 10, -3.415, 0.107 + 0.089, d, h) * 5.0 }
+    ],
+    [TreePreset.Birch]: [
+        { source: "F17 Betula pendula/pubescens", dbh_min: 0.6, dbh_max: 38, leaf_area: (d) => Math.exp(-1.5663) * Math.pow(d, 1.8857) * 1.169 }
+    ]
+};
+
+/**
+ * FIA's ratings of a healthy crown seen from the side: crown density, the share of the crown outline that foliage,
+ * branches and reproductive structures block, and foliage transparency, the skylight through the foliated part
+ * [Randolph 2006, as cited in `CROWN_FILLING_BRIEF_2026_10_26.md`].
+ * @type {{density_min: number, density_max: number, transparency: number}}
+ */
+export const TREE_CROWN_RATING_TARGET = { density_min: 0.45, density_max: 0.51, transparency: 0.15 };
+
+/**
+ * The leaf area a measured tree of a preset's species carries at breast-height diameter `dbh_cm` and height
+ * `height_m`: the range over the allometries that hold it, and every allometry's value with whether `dbh_cm` is inside
+ * its sample. `null` for a species with none.
+ *
+ * @param {TreePreset|string} preset
+ * @param {number} dbh_cm
+ * @param {number} height_m
+ * @returns {{low: number, high: number, values: Array<{source: string, leaf_area: number, in_sample: boolean}>}|null}
+ */
+export function tree_expected_leaf_area(preset, dbh_cm, height_m) {
+    const list = TREE_LEAF_AREA_ALLOMETRY[preset];
+    if (list === undefined) {
+        return null;
+    }
+    const values = list.map(a => ({
+        source: a.source,
+        leaf_area: a.leaf_area(dbh_cm, height_m),
+        in_sample: dbh_cm >= a.dbh_min && dbh_cm <= a.dbh_max
+    }));
+    let low = Infinity, high = -Infinity;
+    for (const v of values) {
+        low = Math.min(low, v.leaf_area);
+        high = Math.max(high, v.leaf_area);
+    }
+    return { low, high, values };
+}

package/src/generation/foliage/analysis/tree_render_cost.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Mean area (m^2) a tree's drawn envelope shows from the side, over every azimuth: the envelope is the convex hull of
+ * the drawn vertices in each of `slices` equal horizontal slices, and a convex slice's mean width over azimuths is its
+ * perimeter over PI (Cauchy), so the area is the sum of `perimeter / PI * thickness`. It is what a viewer at the
+ * tree's height sees of it, the part of the screen the tree's triangles are spent on.
+ *
+ * @param {Array<ArrayLike<number>>} position_arrays vertex positions, 3 per vertex, y up
+ * @param {number} [slices] horizontal slices the height is cut into; the measure's resolution
+ * @returns {number}
+ */
+export function tree_envelope_side_area(position_arrays: Array<ArrayLike<number>>, slices?: number): number;
+/**
+ * What a tree grown as `skeleton` shows from the side, m^2: `tree_envelope_side_area` of its wood's nodes and every
+ * leaf's card, whatever an LOD draws them as.
+ *
+ * @param {import("../skeleton/TreeSkeleton.js").TreeSkeleton} skeleton
+ * @param {import("../../../shade/renderer/geometry/Geometry.js").Geometry|null} leaves every leaf's card
+ *        (`tree_mesh_build_foliage`), `null` for a leafless tree
+ * @returns {number}
+ */
+export function tree_grown_side_area(skeleton: import("../skeleton/TreeSkeleton.js").TreeSkeleton, leaves: import("../../../shade/renderer/geometry/Geometry.js").Geometry | null): number;
+/**
+ * @typedef {Object} TreeRenderCost
+ * @property {number} side_area m^2, `tree_grown_side_area`: what the tree grew shows from the side
+ * @property {number[]} triangles bark and foliage triangles of each LOD
+ * @property {number[]} triangle_density each LOD's triangles per m^2 of `side_area`
+ * @property {number[]} joints each LOD's wind joints
+ * @property {number[]} joint_density each LOD's joints per m^2 of `side_area`
+ * @property {number} texture_bytes the base levels of every foliage texture its LODs draw with, each counted once
+ * @property {number} texture_density `texture_bytes` per m^2 of `side_area`
+ */
+/**
+ * What a generated tree costs to draw: its triangles and wind joints at every LOD and its foliage textures, each per
+ * square metre of what the tree shows from the side. A bigger tree covers more of the screen and may spend proportionately more.
+ *
+ * @param {import("../asset/TreeAsset.js").TreeAsset} asset from `generate_tree`
+ * @returns {TreeRenderCost}
+ */
+export function tree_render_cost(asset: import("../asset/TreeAsset.js").TreeAsset): TreeRenderCost;
+/**
+ * The most a generated tree may spend per square metre it shows from the side (`tree_render_cost`), at each LOD and in
+ * wind joints: the densest of the presets at 6aff5265e (2026-10-25), the last generator whose trees were drawn in real
+ * time, before twigs were meshed shoot by shoot (seed 1337), over `tree_grown_side_area` (its LOD0 drew every leaf's
+ * card). Triangles: the willow at LOD0 and LOD1, the shrub at LOD2; joints, which every LOD's rig is held to: the
+ * shrub; foliage texture bytes, every map's base level, which all of a tree's LODs share: the shrub, whose leaf atlas
+ * was the 640 KiB every preset's was. The fern was 7,065 triangles per m^2 at LOD0 there, nine times the willow, and
+ * its atlas 1.3 MiB per m^2, and is held to the same ceiling.
+ *
+ * A ceiling, not a target: a tree spends what its look needs, up to this.
+ *
+ * @type {{triangle_density: number[], joint_density: number, texture_density: number}}
+ */
+export const TREE_RENDER_COST_CEILING: {
+    triangle_density: number[];
+    joint_density: number;
+    texture_density: number;
+};
+export type TreeRenderCost = {
+    /**
+     * m^2, `tree_grown_side_area`: what the tree grew shows from the side
+     */
+    side_area: number;
+    /**
+     * bark and foliage triangles of each LOD
+     */
+    triangles: number[];
+    /**
+     * each LOD's triangles per m^2 of `side_area`
+     */
+    triangle_density: number[];
+    /**
+     * each LOD's wind joints
+     */
+    joints: number[];
+    /**
+     * each LOD's joints per m^2 of `side_area`
+     */
+    joint_density: number[];
+    /**
+     * the base levels of every foliage texture its LODs draw with, each counted once
+     */
+    texture_bytes: number;
+    /**
+     * `texture_bytes` per m^2 of `side_area`
+     */
+    texture_density: number;
+};
+//# sourceMappingURL=tree_render_cost.d.ts.map

package/src/generation/foliage/analysis/tree_render_cost.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tree_render_cost.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/analysis/tree_render_cost.js"],"names":[],"mappings":"AAKA;;;;;;;;;GASG;AACH,yDAJW,MAAM,UAAU,MAAM,CAAC,CAAC,WACxB,MAAM,GACJ,MAAM,CA8ClB;AAiBD;;;;;;;;GAQG;AACH,+CALW,OAAO,6BAA6B,EAAE,YAAY,UAClD,OAAO,8CAA8C,EAAE,QAAQ,GAAC,IAAI,GAElE,MAAM,CAYlB;AAaD;;;;;;;;;GASG;AAEH;;;;;;GAMG;AACH,wCAHW,OAAO,uBAAuB,EAAE,SAAS,GACvC,cAAc,CAgC1B;AA/FD;;;;;;;;;;;;GAYG;AACH,uCAFU;IAAC,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAAC,aAAa,EAAE,MAAM,CAAC;IAAC,eAAe,EAAE,MAAM,CAAA;CAAC,CAE4C;;;;;eAoCpH,MAAM;;;;eACN,MAAM,EAAE;;;;sBACR,MAAM,EAAE;;;;YACR,MAAM,EAAE;;;;mBACR,MAAM,EAAE;;;;mBACR,MAAM;;;;qBACN,MAAM"}

package/src/generation/foliage/analysis/tree_render_cost.js

@@ -0,0 +1,157 @@
+import { assert } from "../../../core/assert.js";
+import { convex_hull_monotone_2d } from "../../../core/geom/2d/convex-hull/convex_hull_monotone_2d.js";
+import { StandardAttributes } from "../../../shade/renderer/geometry/StandardAttributes.js";
+import { tree_mesh_build_foliage } from "../mesh/tree_mesh_build_foliage.js";
+
+/**
+ * Mean area (m^2) a tree's drawn envelope shows from the side, over every azimuth: the envelope is the convex hull of
+ * the drawn vertices in each of `slices` equal horizontal slices, and a convex slice's mean width over azimuths is its
+ * perimeter over PI (Cauchy), so the area is the sum of `perimeter / PI * thickness`. It is what a viewer at the
+ * tree's height sees of it, the part of the screen the tree's triangles are spent on.
+ *
+ * @param {Array<ArrayLike<number>>} position_arrays vertex positions, 3 per vertex, y up
+ * @param {number} [slices] horizontal slices the height is cut into; the measure's resolution
+ * @returns {number}
+ */
+export function tree_envelope_side_area(position_arrays, slices = 64) {
+    assert.isNonNegativeInteger(slices, 'slices');
+    assert.greaterThan(slices, 0, 'slices');
+
+    let y_min = Infinity;
+    let y_max = -Infinity;
+    for (const p of position_arrays) {
+        for (let i = 1; i < p.length; i += 3) {
+            if (p[i] < y_min) y_min = p[i];
+            if (p[i] > y_max) y_max = p[i];
+        }
+    }
+    if (!(y_max > y_min)) {
+        return 0;
+    }
+
+    const thickness = (y_max - y_min) / slices;
+    const bins = [];
+    for (let s = 0; s < slices; s++) {
+        bins.push([]);
+    }
+    for (const p of position_arrays) {
+        for (let i = 0; i < p.length; i += 3) {
+            const s = Math.min(slices - 1, Math.floor((p[i + 1] - y_min) / thickness));
+            bins[s].push(p[i], p[i + 2]);
+        }
+    }
+
+    let area = 0;
+    for (let s = 0; s < slices; s++) {
+        const points = bins[s];
+        if (points.length < 4) {
+            continue;
+        }
+        const hull = convex_hull_monotone_2d(points);
+        let perimeter = 0;
+        for (let k = 0; k < hull.length; k++) {
+            const a = hull[k] * 2;
+            const b = hull[(k + 1) % hull.length] * 2;
+            perimeter += Math.hypot(points[b] - points[a], points[b + 1] - points[a + 1]);
+        }
+        area += perimeter / Math.PI * thickness;
+    }
+    return area;
+}
+
+/**
+ * The most a generated tree may spend per square metre it shows from the side (`tree_render_cost`), at each LOD and in
+ * wind joints: the densest of the presets at 6aff5265e (2026-10-25), the last generator whose trees were drawn in real
+ * time, before twigs were meshed shoot by shoot (seed 1337), over `tree_grown_side_area` (its LOD0 drew every leaf's
+ * card). Triangles: the willow at LOD0 and LOD1, the shrub at LOD2; joints, which every LOD's rig is held to: the
+ * shrub; foliage texture bytes, every map's base level, which all of a tree's LODs share: the shrub, whose leaf atlas
+ * was the 640 KiB every preset's was. The fern was 7,065 triangles per m^2 at LOD0 there, nine times the willow, and
+ * its atlas 1.3 MiB per m^2, and is held to the same ceiling.
+ *
+ * A ceiling, not a target: a tree spends what its look needs, up to this.
+ *
+ * @type {{triangle_density: number[], joint_density: number, texture_density: number}}
+ */
+export const TREE_RENDER_COST_CEILING = { triangle_density: [761.2, 412.3, 96.2], joint_density: 16.89, texture_density: 240667 };
+
+/**
+ * What a tree grown as `skeleton` shows from the side, m^2: `tree_envelope_side_area` of its wood's nodes and every
+ * leaf's card, whatever an LOD draws them as.
+ *
+ * @param {import("../skeleton/TreeSkeleton.js").TreeSkeleton} skeleton
+ * @param {import("../../../shade/renderer/geometry/Geometry.js").Geometry|null} leaves every leaf's card
+ *        (`tree_mesh_build_foliage`), `null` for a leafless tree
+ * @returns {number}
+ */
+export function tree_grown_side_area(skeleton, leaves) {
+    const nodes = new Float32Array(skeleton.node_count * 3);
+    for (let v = 0; v < skeleton.node_count; v++) {
+        skeleton.node_read_position(nodes, v * 3, v);
+    }
+    const shown = [nodes];
+    if (leaves !== null) {
+        shown.push(leaves.getAttribute(StandardAttributes.Position).data);
+    }
+    return tree_envelope_side_area(shown);
+}
+
+/**
+ * @param {import("../../../shade/renderer/geometry/Geometry.js").Geometry|null} geometry
+ * @returns {number}
+ */
+function triangle_count(geometry) {
+    if (geometry === null || geometry.index === null) {
+        return 0;
+    }
+    return geometry.index.data.length / 3;
+}
+
+/**
+ * @typedef {Object} TreeRenderCost
+ * @property {number} side_area m^2, `tree_grown_side_area`: what the tree grew shows from the side
+ * @property {number[]} triangles bark and foliage triangles of each LOD
+ * @property {number[]} triangle_density each LOD's triangles per m^2 of `side_area`
+ * @property {number[]} joints each LOD's wind joints
+ * @property {number[]} joint_density each LOD's joints per m^2 of `side_area`
+ * @property {number} texture_bytes the base levels of every foliage texture its LODs draw with, each counted once
+ * @property {number} texture_density `texture_bytes` per m^2 of `side_area`
+ */
+
+/**
+ * What a generated tree costs to draw: its triangles and wind joints at every LOD and its foliage textures, each per
+ * square metre of what the tree shows from the side. A bigger tree covers more of the screen and may spend proportionately more.
+ *
+ * @param {import("../asset/TreeAsset.js").TreeAsset} asset from `generate_tree`
+ * @returns {TreeRenderCost}
+ */
+export function tree_render_cost(asset) {
+    assert.greaterThan(asset.lods.length, 0, 'asset.lods.length');
+
+    const leaves = asset.attachments.count > 0
+        ? tree_mesh_build_foliage(asset.skeleton, asset.attachments, asset.config, asset.foliage_cutout)
+        : null;
+    const side_area = tree_grown_side_area(asset.skeleton, leaves);
+    assert.greaterThan(side_area, 0, 'side_area');
+
+    const triangles = asset.lods.map(lod => triangle_count(lod.bark_geometry) + triangle_count(lod.foliage_geometry));
+    const joints = asset.lods.map(lod => lod.joint_count);
+    const textures = new Set();
+    for (const lod of asset.lods) {
+        const material = lod.foliage_material;
+        if (material === null) continue;
+        for (const texture of [material.texture_albedo, material.texture_normal, material.texture_orm]) {
+            if (texture) textures.add(texture.image.source);
+        }
+    }
+    let texture_bytes = 0;
+    for (const image of textures) texture_bytes += image.width * image.height * image.itemSize;
+    return {
+        side_area,
+        triangles,
+        triangle_density: triangles.map(t => t / side_area),
+        joints,
+        joint_density: joints.map(j => j / side_area),
+        texture_bytes,
+        texture_density: texture_bytes / side_area
+    };
+}

package/src/generation/foliage/asset/TreeAsset.d.ts

@@ -23,15 +23,11 @@ export class TreeAsset {
      */
     attachments: import("../mesh/foliage_collect_attachments.js").FoliageAttachmentSet;
     /**
-     * Extracted structural skin joint descriptors.
+     * The wind joints of all the wood as grown, which `attachments` are bound to; no LOD draws it, each has its own
+     * (`TreeLODAsset.skin_info`).
      * @type {ReturnType<import("../skeleton/tree_skeleton_assign_skin_joints.js").tree_skeleton_assign_skin_joints>}
      */
     skin_info: ReturnType<typeof import("../skeleton/tree_skeleton_assign_skin_joints.js").tree_skeleton_assign_skin_joints>;
-    /**
-     * GPU fluid-driven foliage wind rig (`name = "foliage_wind"`), or `null` if wind disabled.
-     * @type {import("../../../shade/renderer/animation/foliage/FoliageWindRig.js").FoliageWindRig|null}
-     */
-    wind_rig: import("../../../shade/renderer/animation/foliage/FoliageWindRig.js").FoliageWindRig | null;
     /**
      * Procedural bark PBR `StandardShadeMaterial` shared across all LODs.
      * @type {import("../../../shade/renderer/material/StandardShadeMaterial.js").StandardShadeMaterial}
@@ -72,6 +68,11 @@ export class TreeAsset {
      * @returns {import("../../../shade/renderer/geometry/MeshletGeometry.js").MeshletGeometry|null}
      */
     get foliage_meshlet_geometry(): import("../../../shade/renderer/geometry/MeshletGeometry.js").MeshletGeometry;
+    /**
+     * Highest-detail (`lods[0]`) GPU fluid-driven foliage wind rig, or `null` if wind is disabled.
+     * @returns {import("../../../shade/renderer/animation/foliage/FoliageWindRig.js").FoliageWindRig|null}
+     */
+    get wind_rig(): import("../../../shade/renderer/animation/foliage/FoliageWindRig.js").FoliageWindRig;
     /**
      * Highest-detail (`lods[0]`) `SceneBundle` (lazy memoized).
      * @returns {import("../../../shade/renderer/loader/SceneBundle.js").SceneBundle|null}

package/src/generation/foliage/asset/TreeAsset.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TreeAsset.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/asset/TreeAsset.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH;IACI;;;OAGG;IACH,QAFU,OAAO,gCAAgC,EAAE,iBAAiB,CAEtD;IAEd;;;OAGG;IACH,UAFU,OAAO,6BAA6B,EAAE,YAAY,CAE5C;IAEhB;;;OAGG;IACH,aAFU,OAAO,wCAAwC,EAAE,oBAAoB,CAE5D;IAEnB;;;OAGG;IACH,WAFU,6GAAsG,CAE/F;IAEjB;;;OAGG;IACH,UAFU,OAAO,6DAA6D,EAAE,cAAc,GAAC,IAAI,CAEnF;IAEhB;;;OAGG;IACH,eAFU,OAAO,2DAA2D,EAAE,qBAAqB,CAE9E;IAErB;;;OAGG;IACH,kBAFU,OAAO,2DAA2D,EAAE,qBAAqB,CAE3E;IAExB;;;OAGG;IACH,gBAFU,OAAO,mCAAmC,EAAE,kBAAkB,GAAC,IAAI,CAEvD;IAEtB;;;OAGG;IACH,MAFU,OAAO,mBAAmB,EAAE,YAAY,EAAE,CAE1C;IAEV;;;OAGG;IACH,qFAEC;IAED;;;OAGG;IACH,wFAEC;IAED;;;OAGG;IACH,2GAEC;IAED;;;OAGG;IACH,8GAEC;IAED;;;OAGG;IACH,wFAEC;IAED;;;OAGG;IACH,0EAEC;IAGL;;;OAGG;IACH,sBAFU,OAAO,CAEc;CAN9B"}
+{"version":3,"file":"TreeAsset.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/asset/TreeAsset.js"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH;IACI;;;OAGG;IACH,QAFU,OAAO,gCAAgC,EAAE,iBAAiB,CAEtD;IAEd;;;OAGG;IACH,UAFU,OAAO,6BAA6B,EAAE,YAAY,CAE5C;IAEhB;;;OAGG;IACH,aAFU,OAAO,wCAAwC,EAAE,oBAAoB,CAE5D;IAEnB;;;;OAIG;IACH,WAFU,6GAAsG,CAE/F;IAEjB;;;OAGG;IACH,eAFU,OAAO,2DAA2D,EAAE,qBAAqB,CAE9E;IAErB;;;OAGG;IACH,kBAFU,OAAO,2DAA2D,EAAE,qBAAqB,CAE3E;IAExB;;;OAGG;IACH,gBAFU,OAAO,mCAAmC,EAAE,kBAAkB,GAAC,IAAI,CAEvD;IAEtB;;;OAGG;IACH,MAFU,OAAO,mBAAmB,EAAE,YAAY,EAAE,CAE1C;IAEV;;;OAGG;IACH,qFAEC;IAED;;;OAGG;IACH,wFAEC;IAED;;;OAGG;IACH,2GAEC;IAED;;;OAGG;IACH,8GAEC;IAED;;;OAGG;IACH,qGAEC;IAED;;;OAGG;IACH,wFAEC;IAED;;;OAGG;IACH,0EAEC;IAGL;;;OAGG;IACH,sBAFU,OAAO,CAEc;CAN9B"}

package/src/generation/foliage/asset/TreeAsset.js

@@ -26,17 +26,12 @@ export class TreeAsset {
     attachments = null;
 
     /**
-     * Extracted structural skin joint descriptors.
+     * The wind joints of all the wood as grown, which `attachments` are bound to; no LOD draws it, each has its own
+     * (`TreeLODAsset.skin_info`).
      * @type {ReturnType<import("../skeleton/tree_skeleton_assign_skin_joints.js").tree_skeleton_assign_skin_joints>}
      */
     skin_info = null;
 
-    /**
-     * GPU fluid-driven foliage wind rig (`name = "foliage_wind"`), or `null` if wind disabled.
-     * @type {import("../../../shade/renderer/animation/foliage/FoliageWindRig.js").FoliageWindRig|null}
-     */
-    wind_rig = null;
-
     /**
      * Procedural bark PBR `StandardShadeMaterial` shared across all LODs.
      * @type {import("../../../shade/renderer/material/StandardShadeMaterial.js").StandardShadeMaterial}
@@ -93,6 +88,14 @@ export class TreeAsset {
         return this.lods.length > 0 ? this.lods[0].foliage_meshlet_geometry : null;
     }
 
+    /**
+     * Highest-detail (`lods[0]`) GPU fluid-driven foliage wind rig, or `null` if wind is disabled.
+     * @returns {import("../../../shade/renderer/animation/foliage/FoliageWindRig.js").FoliageWindRig|null}
+     */
+    get wind_rig() {
+        return this.lods.length > 0 ? this.lods[0].wind_rig : null;
+    }
+
     /**
      * Highest-detail (`lods[0]`) `SceneBundle` (lazy memoized).
      * @returns {import("../../../shade/renderer/loader/SceneBundle.js").SceneBundle|null}

package/src/generation/foliage/asset/TreeLODAsset.d.ts

@@ -17,13 +17,21 @@ export class TreeLODAsset {
      */
     name: string;
     /**
-     * Configures lazy builders for `bark_geometry` and `foliage_geometry` so coarse LODs are only
-     * triangulated when accessed.
+     * What the LOD is drawn to: its error, the one this tree's ceiling allows (`tree_lod_plan`).
+     * @type {import("../config/TreeLODConfig.js").TreeLODConfig|null}
+     */
+    config: import("../config/TreeLODConfig.js").TreeLODConfig | null;
+    /**
+     * Configures lazy builders for the bark and the foliage, so an LOD is only built when it is drawn. The foliage's
+     * geometry and material are built together, `null` for a tree without foliage.
      *
      * @param {() => import("../../../shade/renderer/geometry/Geometry.js").Geometry} bark_builder
-     * @param {() => import("../../../shade/renderer/geometry/Geometry.js").Geometry|null} foliage_builder
+     * @param {() => {geometry: import("../../../shade/renderer/geometry/Geometry.js").Geometry, material: import("../../../shade/renderer/material/StandardShadeMaterial.js").StandardShadeMaterial}|null} foliage_builder
      */
-    configure_lazy_geometries(bark_builder: () => import("../../../shade/renderer/geometry/Geometry.js").Geometry, foliage_builder: () => import("../../../shade/renderer/geometry/Geometry.js").Geometry | null): void;
+    configure_lazy_geometries(bark_builder: () => import("../../../shade/renderer/geometry/Geometry.js").Geometry, foliage_builder: () => {
+        geometry: import("../../../shade/renderer/geometry/Geometry.js").Geometry;
+        material: import("../../../shade/renderer/material/StandardShadeMaterial.js").StandardShadeMaterial;
+    } | null): void;
     /**
      * @param {import("../../../shade/renderer/geometry/Geometry.js").Geometry} value
      */
@@ -38,22 +46,27 @@ export class TreeLODAsset {
      */
     set foliage_geometry(value: import("../../../shade/renderer/geometry/Geometry.js").Geometry);
     /**
-     * Triangulated foliage card `Geometry`, or `null` if foliage is disabled / keep_ratio = 0.
+     * The LOD's foliage: its cluster cards, or `null` for a tree without foliage.
      * @returns {import("../../../shade/renderer/geometry/Geometry.js").Geometry|null}
      */
     get foliage_geometry(): import("../../../shade/renderer/geometry/Geometry.js").Geometry;
     /**
-     * Shared procedural bark `StandardShadeMaterial`.
-     * @type {import("../../../shade/renderer/material/StandardShadeMaterial.js").StandardShadeMaterial}
+     * @param {import("../../../shade/renderer/material/StandardShadeMaterial.js").StandardShadeMaterial|null} value
      */
-    bark_material: import("../../../shade/renderer/material/StandardShadeMaterial.js").StandardShadeMaterial;
+    set foliage_material(value: import("../../../shade/renderer/material/StandardShadeMaterial.js").StandardShadeMaterial);
     /**
-     * Shared procedural foliage `StandardShadeMaterial`.
+     * The material the LOD's foliage is drawn with: its cluster cards' baked atlas.
+     * @returns {import("../../../shade/renderer/material/StandardShadeMaterial.js").StandardShadeMaterial|null}
+     */
+    get foliage_material(): import("../../../shade/renderer/material/StandardShadeMaterial.js").StandardShadeMaterial;
+    /**
+     * Shared procedural bark `StandardShadeMaterial`.
      * @type {import("../../../shade/renderer/material/StandardShadeMaterial.js").StandardShadeMaterial}
      */
-    foliage_material: import("../../../shade/renderer/material/StandardShadeMaterial.js").StandardShadeMaterial;
+    bark_material: import("../../../shade/renderer/material/StandardShadeMaterial.js").StandardShadeMaterial;
     /**
-     * Structural skin joint hierarchy extracted from the `TreeSkeleton`.
+     * The LOD's wind joints: on the wood it draws, a subset of the finer LOD's (`tree_lod_plan`), or `null` when the
+     * tree has no wind.
      * @type {ReturnType<import("../skeleton/tree_skeleton_assign_skin_joints.js").tree_skeleton_assign_skin_joints>}
      */
     skin_info: ReturnType<typeof import("../skeleton/tree_skeleton_assign_skin_joints.js").tree_skeleton_assign_skin_joints>;

package/src/generation/foliage/asset/TreeLODAsset.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TreeLODAsset.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/asset/TreeLODAsset.js"],"names":[],"mappings":"AAMA;;;;;;GAMG;AACH;IACI;;;OAGG;IACH,OAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,MAFU,MAAM,CAEF;IA2Bd;;;;;;OAMG;IACH,wCAHW,MAAM,OAAO,8CAA8C,EAAE,QAAQ,mBACrE,MAAM,OAAO,8CAA8C,EAAE,QAAQ,GAAC,IAAI,QAQpF;IAcD;;OAEG;IACH,0FAGC;IAlBD;;;OAGG;IACH,qFAMC;IAuBD;;OAEG;IACH,6FAIC;IApBD;;;OAGG;IACH,wFAOC;IAWD;;;OAGG;IACH,eAFU,OAAO,2DAA2D,EAAE,qBAAqB,CAE9E;IAErB;;;OAGG;IACH,kBAFU,OAAO,2DAA2D,EAAE,qBAAqB,CAE3E;IAExB;;;OAGG;IACH,WAFU,6GAAsG,CAE/F;IAEjB;;;OAGG;IACH,UAFU,OAAO,6DAA6D,EAAE,cAAc,GAAC,IAAI,CAEnF;IA2BhB;;;;;OAKG;IACH,2GAKC;IAED;;;;;OAKG;IACH,8GAUC;IAED;;;;;OAKG;IACH,gCAwGC;IAED;;;;OAIG;IACH,0EAKC;IAED;;;OAGG;IACH,0BAEC;IAED;;;OAGG;IACH,2BAIC;IAED;;;OAGG;IACH,6BAIC;IAGL;;;OAGG;IACH,yBAFU,OAAO,CAEoB;;CANpC;4BAhV2B,+CAA+C"}
+{"version":3,"file":"TreeLODAsset.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/asset/TreeLODAsset.js"],"names":[],"mappings":"AAMA;;;;;;GAMG;AACH;IACI;;;OAGG;IACH,OAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,MAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,QAFU,OAAO,4BAA4B,EAAE,aAAa,GAAC,IAAI,CAEnD;IAgCd;;;;;;OAMG;IACH,wCAHW,MAAM,OAAO,8CAA8C,EAAE,QAAQ,mBACrE,MAAM;QAAC,QAAQ,EAAE,OAAO,8CAA8C,EAAE,QAAQ,CAAC;QAAC,QAAQ,EAAE,OAAO,2DAA2D,EAAE,qBAAqB,CAAA;KAAC,GAAC,IAAI,QASrM;IAwBD;;OAEG;IACH,0FAGC;IAlBD;;;OAGG;IACH,qFAMC;IAmBD;;OAEG;IACH,6FAGC;IAfD;;;OAGG;IACH,wFAGC;IAmBD;;OAEG;IACH,uHAGC;IAfD;;;OAGG;IACH,kHAGC;IAUD;;;OAGG;IACH,eAFU,OAAO,2DAA2D,EAAE,qBAAqB,CAE9E;IAErB;;;;OAIG;IACH,WAFU,6GAAsG,CAE/F;IAEjB;;;OAGG;IACH,UAFU,OAAO,6DAA6D,EAAE,cAAc,GAAC,IAAI,CAEnF;IA2BhB;;;;;OAKG;IACH,2GAKC;IAED;;;;;OAKG;IACH,8GAUC;IAED;;;;;OAKG;IACH,gCAwGC;IAED;;;;OAIG;IACH,0EAKC;IAED;;;OAGG;IACH,0BAEC;IAED;;;OAGG;IACH,2BAIC;IAED;;;OAGG;IACH,6BAIC;IAGL;;;OAGG;IACH,yBAFU,OAAO,CAEoB;;CANpC;4BA7W2B,+CAA+C"}