@woosh/meep-engine 3.57.0 → 3.58.0

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

@@ -24,6 +24,12 @@ export class TreeLODAsset {
      */
     name = "tree";
 
+    /**
+     * 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 = null;
+
     /**
      * @type {import("../../../shade/renderer/geometry/Geometry.js").Geometry|null}
      */
@@ -40,9 +46,14 @@ export class TreeLODAsset {
     #foliage_geometry = null;
 
     /**
-     * @type {(() => import("../../../shade/renderer/geometry/Geometry.js").Geometry|null)|null}
+     * @type {(() => {geometry: import("../../../shade/renderer/geometry/Geometry.js").Geometry, material: import("../../../shade/renderer/material/StandardShadeMaterial.js").StandardShadeMaterial}|null)|null}
+     */
+    #foliage_builder = null;
+
+    /**
+     * @type {import("../../../shade/renderer/material/StandardShadeMaterial.js").StandardShadeMaterial|null}
      */
-    #foliage_geometry_builder = null;
+    #foliage_material = null;
 
     /**
      * @type {boolean}
@@ -50,20 +61,31 @@ export class TreeLODAsset {
     #foliage_geometry_built = false;
 
     /**
-     * Configures lazy builders for `bark_geometry` and `foliage_geometry` so coarse LODs are only
-     * triangulated when accessed.
+     * 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, foliage_builder) {
         this.#bark_geometry_builder = bark_builder;
-        this.#foliage_geometry_builder = foliage_builder;
+        this.#foliage_builder = foliage_builder;
         this.#bark_geometry = null;
         this.#foliage_geometry = null;
+        this.#foliage_material = null;
         this.#foliage_geometry_built = false;
     }
 
+    #build_foliage() {
+        if (!this.#foliage_geometry_built && this.#foliage_builder !== null) {
+            this.#foliage_geometry_built = true;
+            const built = this.#foliage_builder();
+            this.#foliage_builder = null;
+            this.#foliage_geometry = built !== null ? built.geometry : null;
+            this.#foliage_material = built !== null ? built.material : null;
+        }
+    }
+
     /**
      * Triangulated bark `Geometry`.
      * @returns {import("../../../shade/renderer/geometry/Geometry.js").Geometry}
@@ -85,15 +107,11 @@ export class TreeLODAsset {
     }
 
     /**
-     * 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() {
-        if (!this.#foliage_geometry_built && this.#foliage_geometry_builder !== null) {
-            this.#foliage_geometry_built = true;
-            this.#foliage_geometry = this.#foliage_geometry_builder();
-            this.#foliage_geometry_builder = null;
-        }
+        this.#build_foliage();
         return this.#foliage_geometry;
     }
 
@@ -101,25 +119,36 @@ export class TreeLODAsset {
      * @param {import("../../../shade/renderer/geometry/Geometry.js").Geometry|null} value
      */
     set foliage_geometry(value) {
+        this.#build_foliage();
         this.#foliage_geometry = value;
-        this.#foliage_geometry_built = true;
-        this.#foliage_geometry_builder = null;
     }
 
     /**
-     * Shared procedural bark `StandardShadeMaterial`.
-     * @type {import("../../../shade/renderer/material/StandardShadeMaterial.js").StandardShadeMaterial}
+     * The material the LOD's foliage is drawn with: its cluster cards' baked atlas.
+     * @returns {import("../../../shade/renderer/material/StandardShadeMaterial.js").StandardShadeMaterial|null}
      */
-    bark_material = null;
+    get foliage_material() {
+        this.#build_foliage();
+        return this.#foliage_material;
+    }
 
     /**
-     * Shared procedural foliage `StandardShadeMaterial`.
+     * @param {import("../../../shade/renderer/material/StandardShadeMaterial.js").StandardShadeMaterial|null} value
+     */
+    set foliage_material(value) {
+        this.#build_foliage();
+        this.#foliage_material = value;
+    }
+
+    /**
+     * Shared procedural bark `StandardShadeMaterial`.
      * @type {import("../../../shade/renderer/material/StandardShadeMaterial.js").StandardShadeMaterial}
      */
-    foliage_material = null;
+    bark_material = null;
 
     /**
-     * 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 = null;

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

@@ -7,6 +7,17 @@
  * - A `TreeSpeciesConfig` instance (`generate_tree(species_config)`).
  * - An options object (`generate_tree({ preset: "birch", seed: 42, crown: { height: 14 }, lod_count: 3 })`).
  *
+ * Each LOD is the tree drawn to a geometric error (`TreeLODConfig.error`): the finest at which its bark and its
+ * foliage, and its wind joints, fit that LOD's `TREE_RENDER_COST_CEILING` over the side area of the leaves and wood
+ * the tree grew (`tree_lod_plan`, `tree_grown_side_area`). Its foliage is one card per cluster (`tree_clusters`), each
+ * drawn with the tile of one of a few cuts (`tree_cluster_representatives`), shared by all its LODs in one atlas as
+ * large as the tree's texture ceiling: baked from the leaves and twigs that cut grew (`tree_cluster_bake`) at the
+ * leaf's own texel, or for a coarser LOD's cut, where the LOD before it is drawn to a pixel. Its rig is on the wood it draws, at a tolerance no finer than its
+ * error, its joints a subset of the finer LOD's, so switching keeps the joints both share.
+ *
+ * The asset's `foliage_material` and `skin_info` are the leaves' and the wood's as grown, which the cards are baked
+ * from and the leaves are bound to; each LOD has its own.
+ *
  * @param {string|import("../config/TreeSpeciesConfig.js").TreeSpeciesConfig|Object} [options={}]
  * @returns {TreeAsset}
  */

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

@@ -1 +1 @@
-{"version":3,"file":"generate_tree.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/asset/generate_tree.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;GAWG;AACH,wCAHW,MAAM,GAAC,OAAO,gCAAgC,EAAE,iBAAiB,MAAO,GACtE,SAAS,CAqFrB;0BAlGyB,gBAAgB"}
+{"version":3,"file":"generate_tree.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/asset/generate_tree.js"],"names":[],"mappings":"AAyBA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wCAHW,MAAM,GAAC,OAAO,gCAAgC,EAAE,iBAAiB,MAAO,GACtE,SAAS,CAyIrB;0BAlKyB,gBAAgB"}

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

@@ -1,16 +1,27 @@
+import { TREE_RENDER_COST_CEILING, tree_grown_side_area } from "../analysis/tree_render_cost.js";
 import { build_tree_wind_rig } from "../animation/build_tree_wind_rig.js";
+import { TREE_LOD_ERROR_FINEST } from "../config/TreeLODConfig.js";
 import { TreePreset } from "../config/TreePreset.js";
 import { FoliageAtlasCutout } from "../material/FoliageAtlasCutout.js";
 import { make_bark_material } from "../material/make_bark_material.js";
+import { foliage_material_from_samplers } from "../material/foliage_material_from_samplers.js";
 import { make_foliage_material } from "../material/make_foliage_material.js";
+import { tree_cluster_bake } from "../material/tree_cluster_bake.js";
 import { foliage_collect_attachments } from "../mesh/foliage_collect_attachments.js";
-import { tree_mesh_build_bark } from "../mesh/tree_mesh_build_bark.js";
+import { foliage_tile_layout } from "../material/foliage_tile.js";
+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_build_bark, tree_mesh_compute_branch_rings } from "../mesh/tree_mesh_build_bark.js";
+import { tree_mesh_build_clusters } from "../mesh/tree_mesh_build_clusters.js";
 import { tree_mesh_build_foliage } from "../mesh/tree_mesh_build_foliage.js";
 import { make_tree_species_preset } from "../presets/make_tree_species_preset.js";
 import { tree_skeleton_assign_skin_joints } from "../skeleton/tree_skeleton_assign_skin_joints.js";
+import { tree_skeleton_bind_skin_joints } from "../skeleton/tree_skeleton_bind_skin_joints.js";
 import { tree_skeleton_grow } from "../skeleton/tree_skeleton_grow.js";
 import { TreeAsset } from "./TreeAsset.js";
 import { TreeLODAsset } from "./TreeLODAsset.js";
+import { tree_lod_plan } from "./tree_lod_plan.js";
 
 /**
  * Turn-key procedural tree and foliage generator.
@@ -21,6 +32,17 @@ import { TreeLODAsset } from "./TreeLODAsset.js";
  * - A `TreeSpeciesConfig` instance (`generate_tree(species_config)`).
  * - An options object (`generate_tree({ preset: "birch", seed: 42, crown: { height: 14 }, lod_count: 3 })`).
  *
+ * Each LOD is the tree drawn to a geometric error (`TreeLODConfig.error`): the finest at which its bark and its
+ * foliage, and its wind joints, fit that LOD's `TREE_RENDER_COST_CEILING` over the side area of the leaves and wood
+ * the tree grew (`tree_lod_plan`, `tree_grown_side_area`). Its foliage is one card per cluster (`tree_clusters`), each
+ * drawn with the tile of one of a few cuts (`tree_cluster_representatives`), shared by all its LODs in one atlas as
+ * large as the tree's texture ceiling: baked from the leaves and twigs that cut grew (`tree_cluster_bake`) at the
+ * leaf's own texel, or for a coarser LOD's cut, where the LOD before it is drawn to a pixel. Its rig is on the wood it draws, at a tolerance no finer than its
+ * error, its joints a subset of the finer LOD's, so switching keeps the joints both share.
+ *
+ * The asset's `foliage_material` and `skin_info` are the leaves' and the wood's as grown, which the cards are baked
+ * from and the leaves are bound to; each LOD has its own.
+ *
  * @param {string|import("../config/TreeSpeciesConfig.js").TreeSpeciesConfig|Object} [options={}]
  * @returns {TreeAsset}
  */
@@ -48,8 +70,8 @@ export function generate_tree(options = {}) {
     }
 
     const skeleton = tree_skeleton_grow(config);
+    // the rig of all the wood as grown, which the leaves as grown are bound to
     const skin_info = tree_skeleton_assign_skin_joints(skeleton, config);
-    const wind_rig = config.wind.enabled ? build_tree_wind_rig(skin_info, config.wind) : null;
 
     const bark_material = custom_bark_material !== null
         ? custom_bark_material
@@ -65,7 +87,14 @@ export function generate_tree(options = {}) {
         foliage_cutout = new FoliageAtlasCutout();
         foliage_material = make_foliage_material(config, foliage_cutout);
     }
-    const attachments = foliage_collect_attachments(skeleton, config, foliage_cutout ?? undefined);
+    // The cards anchor on the bark's rings at the finest LOD's error. The LOD search's first step plans the rings at
+    // TREE_LOD_ERROR_FINEST with the skeleton still bound to the rig as grown, as here: where the two errors are one,
+    // so are the rings, planned once
+    const planned = new Map();
+    if (config.lods[0]?.error === TREE_LOD_ERROR_FINEST) {
+        planned.set(TREE_LOD_ERROR_FINEST, tree_mesh_compute_branch_rings(skeleton, config, config.lods[0]));
+    }
+    const attachments = foliage_collect_attachments(skeleton, config, foliage_cutout ?? undefined, planned.get(TREE_LOD_ERROR_FINEST));
     if (foliage_cutout !== null) {
         // Card tints can brighten as well as darken; the unorm8 vertex colours carry tint / tint_scale and our
         // material multiplies tint_scale back in
@@ -80,24 +109,69 @@ export function generate_tree(options = {}) {
     asset.skeleton = skeleton;
     asset.attachments = attachments;
     asset.skin_info = skin_info;
-    asset.wind_rig = wind_rig;
     asset.bark_material = bark_material;
     asset.foliage_material = foliage_material;
     asset.foliage_cutout = foliage_cutout;
 
+    // every leaf as the tree grew it: what each LOD's cluster cards are baked from, built again for each, as it would
+    // otherwise be held for as long as any LOD is not
+    const has_leaves = attachments.count > 0 && foliage_material !== null;
+    const grow_leaves = () => tree_mesh_build_foliage(skeleton, attachments, config, foliage_cutout);
+    const side_area = tree_grown_side_area(skeleton, has_leaves ? grow_leaves() : null);
+    const plan = tree_lod_plan(skeleton, config, attachments, side_area, config.lods.length, planned);
+    const lod_configs = plan.map((p, i) => {
+        const lod_cfg = config.lods[i].clone();
+        lod_cfg.error = p.error;
+        return lod_cfg;
+    });
+
+    // every LOD's cluster cards drawn with a few cuts' tiles, one atlas for all of them, as many as the tree's texture
+    // ceiling holds: built with the first LOD's foliage
+    let shared = null;
+    const cluster_atlas = () => {
+        if (shared === null) {
+            const leaves = grow_leaves();
+            const lods = lod_configs.map((lod_cfg) => {
+                const clusters = tree_clusters(skeleton, attachments, tree_mesh_compute_branch_rings(skeleton, config, lod_cfg));
+                return { clusters, cards: tree_cluster_cards(skeleton, attachments, leaves, clusters), error: lod_cfg.error };
+            });
+            const tiles = foliage_tile_layout(config);
+            const representatives = tree_cluster_representatives(skeleton, attachments, leaves, lods, tiles.texel,
+                tiles.legible_texel, TREE_RENDER_COST_CEILING.texture_density * side_area);
+            const bake = tree_cluster_bake(skeleton, config, representatives.cards, attachments, leaves, foliage_material, representatives.texels);
+            const material = foliage_material_from_samplers(bake.albedo, bake.normal, bake.orm, "foliage_clusters");
+            shared = { lods, representatives, bake, material };
+        }
+        return shared;
+    };
+
     for (let i = 0; i < config.lods.length; i++) {
-        const lod_cfg = config.lods[i];
+        const lod_cfg = lod_configs[i];
+        const lod_skin = plan[i].skin_info;
         const lod_asset = new TreeLODAsset();
         lod_asset.level = i;
         lod_asset.name = config.name || "tree";
         lod_asset.configure_lazy_geometries(
-            () => tree_mesh_build_bark(skeleton, config, lod_cfg),
-            () => tree_mesh_build_foliage(skeleton, attachments, config, lod_cfg, foliage_cutout)
+            () => {
+                tree_skeleton_bind_skin_joints(skeleton, lod_skin);
+                return tree_mesh_build_bark(skeleton, config, lod_cfg);
+            },
+            () => {
+                if (!has_leaves) return null;
+                tree_skeleton_bind_skin_joints(skeleton, lod_skin);
+                const clusters = tree_clusters(skeleton, attachments, tree_mesh_compute_branch_rings(skeleton, config, lod_cfg));
+                // its clusters again, on its own rig; their cards are where they were
+                const { lods, representatives, bake, material } = cluster_atlas();
+                const cards = lods[i].cards;
+                const geometry = tree_mesh_build_clusters(skeleton, config, clusters, cards, representatives.placements[i], bake);
+                if (geometry === null) return null;
+                return { geometry, material };
+            }
         );
         lod_asset.bark_material = bark_material;
-        lod_asset.foliage_material = foliage_material;
-        lod_asset.skin_info = config.wind.enabled ? skin_info : null;
-        lod_asset.wind_rig = wind_rig;
+        lod_asset.skin_info = config.wind.enabled ? lod_skin : null;
+        lod_asset.wind_rig = config.wind.enabled ? build_tree_wind_rig(lod_skin, config.wind) : null;
+        lod_asset.config = lod_cfg;
 
         if (eager_meshlets) {
             void lod_asset.prefab;

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

@@ -0,0 +1,71 @@
+/**
+ * Triangles a tree drawn to `error` costs: its bark (as `tree_mesh_build_bark` draws it) and a hull for each of its
+ * clusters' cards (`tree_clusters`, `tree_cluster_cards`, `tree_mesh_build_clusters`).
+ *
+ * @param {import("../skeleton/TreeSkeleton.js").TreeSkeleton} skeleton
+ * @param {import("../config/TreeSpeciesConfig.js").TreeSpeciesConfig} species
+ * @param {import("../mesh/foliage_collect_attachments.js").FoliageAttachmentSet} attachments
+ * @param {number} error m
+ * @returns {number}
+ */
+export function tree_triangles_at_error(skeleton: import("../skeleton/TreeSkeleton.js").TreeSkeleton, species: import("../config/TreeSpeciesConfig.js").TreeSpeciesConfig, attachments: import("../mesh/foliage_collect_attachments.js").FoliageAttachmentSet, error: number): number;
+/**
+ * One LOD of a tree: the error it is drawn to and the rig on the wood it draws.
+ *
+ * @typedef {Object} TreeLODPlan
+ * @property {number} error m
+ * @property {ReturnType<typeof tree_skeleton_assign_skin_joints>} skin_info its wind joints
+ */
+/**
+ * Each LOD's geometric error and rig: the finest error at which the tree fits that LOD's
+ * `TREE_RENDER_COST_CEILING` over `side_area` (`tree_grown_side_area`), its bark and cluster cards in triangles and,
+ * when it is rigged for wind, its joints, no finer than the LOD before it and no finer than `TREE_LOD_ERROR_FINEST`:
+ * each halving of the error quadruples the cluster cards' texels, which no ceiling yet bounds. Errors are tried a
+ * half-octave apart ({@link ERROR_STEP}), up from the finest until the tree fits, or until it draws no wood at all.
+ *
+ * An LOD's rig (`tree_skeleton_assign_skin_joints`) is on the wood it draws, at a tolerance no finer than its error
+ * (a sway smaller than the shape's error cannot be seen), and its joints are a subset of the finer LOD's. The
+ * skeleton is left bound to the coarsest; `tree_skeleton_bind_skin_joints` binds another.
+ *
+ * @param {import("../skeleton/TreeSkeleton.js").TreeSkeleton} skeleton
+ * @param {import("../config/TreeSpeciesConfig.js").TreeSpeciesConfig} species
+ * @param {import("../mesh/foliage_collect_attachments.js").FoliageAttachmentSet} attachments
+ * @param {number} side_area m^2
+ * @param {number} lod_count
+ * @param {Map<number, ReturnType<typeof tree_mesh_compute_branch_rings>>} [planned] the bark's rings the caller has
+ *        already planned (`tree_mesh_compute_branch_rings`), by error: the search takes them rather than planning them
+ *        again
+ * @returns {TreeLODPlan[]}
+ */
+export function tree_lod_plan(skeleton: import("../skeleton/TreeSkeleton.js").TreeSkeleton, species: import("../config/TreeSpeciesConfig.js").TreeSpeciesConfig, attachments: import("../mesh/foliage_collect_attachments.js").FoliageAttachmentSet, side_area: number, lod_count: number, planned?: Map<number, Map<number, {
+    cx: number;
+    cy: number;
+    cz: number;
+    r: number;
+    m: number;
+    t_norm: number;
+    flute_amp: number;
+    j0: number;
+    j1: number;
+    j2: number;
+    j3: number;
+    w0: number;
+    w1: number;
+    w2: number;
+    w3: number;
+}[]>>): TreeLODPlan[];
+/**
+ * One LOD of a tree: the error it is drawn to and the rig on the wood it draws.
+ */
+export type TreeLODPlan = {
+    /**
+     * m
+     */
+    error: number;
+    /**
+     * its wind joints
+     */
+    skin_info: ReturnType<typeof tree_skeleton_assign_skin_joints>;
+};
+import { tree_skeleton_assign_skin_joints } from "../skeleton/tree_skeleton_assign_skin_joints.js";
+//# sourceMappingURL=tree_lod_plan.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tree_lod_plan.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/asset/tree_lod_plan.js"],"names":[],"mappings":"AAqCA;;;;;;;;;GASG;AACH,kDANW,OAAO,6BAA6B,EAAE,YAAY,WAClD,OAAO,gCAAgC,EAAE,iBAAiB,eAC1D,OAAO,wCAAwC,EAAE,oBAAoB,SACrE,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wCAVW,OAAO,6BAA6B,EAAE,YAAY,WAClD,OAAO,gCAAgC,EAAE,iBAAiB,eAC1D,OAAO,wCAAwC,EAAE,oBAAoB,aACrE,MAAM,aACN,MAAM,YACN,IAAI,MAAM;;;;;;;;;;;;;;;;KAAoD,GAG5D,WAAW,EAAE,CAwCzB;;;;;;;;WA/Da,MAAM;;;;eACN,WAAW,uCAAuC,CAAC;;iDAnDhB,iDAAiD"}

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

@@ -0,0 +1,119 @@
+import { TREE_RENDER_COST_CEILING } from "../analysis/tree_render_cost.js";
+import { TREE_LOD_ERROR_FINEST } from "../config/TreeLODConfig.js";
+import { CUTOUT_HULL_VERTEX_COUNT } from "../material/FoliageAtlasCutout.js";
+import { tree_clusters } from "../mesh/tree_clusters.js";
+import { tree_mesh_compute_branch_rings } from "../mesh/tree_mesh_build_bark.js";
+import { tree_skeleton_assign_skin_joints } from "../skeleton/tree_skeleton_assign_skin_joints.js";
+
+/**
+ * Ratio between consecutive errors the search tries: each a half-octave coarser than the last.
+ * @type {number}
+ */
+const ERROR_STEP = Math.SQRT2;
+
+/**
+ * Triangles the bark `rings` and the cluster cards of the wood they leave out cost.
+ *
+ * @param {import("../skeleton/TreeSkeleton.js").TreeSkeleton} skeleton
+ * @param {import("../mesh/foliage_collect_attachments.js").FoliageAttachmentSet} attachments
+ * @param {Map<number, Array<{m: number}>>} rings
+ * @returns {number}
+ */
+function triangles_of(skeleton, attachments, rings) {
+    let triangles = 0;
+    for (const list of rings.values()) {
+        for (let i = 1; i < list.length; i++) {
+            triangles += list[i - 1].m + list[i].m;
+        }
+        // the tip's cap
+        triangles += list[list.length - 1].m;
+    }
+    if (attachments.count > 0 || rings.size < skeleton.branch_count) {
+        // a card per cluster
+        triangles += tree_clusters(skeleton, attachments, rings).length * CUTOUT_HULL_VERTEX_COUNT;
+    }
+    return triangles;
+}
+
+/**
+ * Triangles a tree drawn to `error` costs: its bark (as `tree_mesh_build_bark` draws it) and a hull for each of its
+ * clusters' cards (`tree_clusters`, `tree_cluster_cards`, `tree_mesh_build_clusters`).
+ *
+ * @param {import("../skeleton/TreeSkeleton.js").TreeSkeleton} skeleton
+ * @param {import("../config/TreeSpeciesConfig.js").TreeSpeciesConfig} species
+ * @param {import("../mesh/foliage_collect_attachments.js").FoliageAttachmentSet} attachments
+ * @param {number} error m
+ * @returns {number}
+ */
+export function tree_triangles_at_error(skeleton, species, attachments, error) {
+    return triangles_of(skeleton, attachments, tree_mesh_compute_branch_rings(skeleton, species, { error }));
+}
+
+/**
+ * One LOD of a tree: the error it is drawn to and the rig on the wood it draws.
+ *
+ * @typedef {Object} TreeLODPlan
+ * @property {number} error m
+ * @property {ReturnType<typeof tree_skeleton_assign_skin_joints>} skin_info its wind joints
+ */
+
+/**
+ * Each LOD's geometric error and rig: the finest error at which the tree fits that LOD's
+ * `TREE_RENDER_COST_CEILING` over `side_area` (`tree_grown_side_area`), its bark and cluster cards in triangles and,
+ * when it is rigged for wind, its joints, no finer than the LOD before it and no finer than `TREE_LOD_ERROR_FINEST`:
+ * each halving of the error quadruples the cluster cards' texels, which no ceiling yet bounds. Errors are tried a
+ * half-octave apart ({@link ERROR_STEP}), up from the finest until the tree fits, or until it draws no wood at all.
+ *
+ * An LOD's rig (`tree_skeleton_assign_skin_joints`) is on the wood it draws, at a tolerance no finer than its error
+ * (a sway smaller than the shape's error cannot be seen), and its joints are a subset of the finer LOD's. The
+ * skeleton is left bound to the coarsest; `tree_skeleton_bind_skin_joints` binds another.
+ *
+ * @param {import("../skeleton/TreeSkeleton.js").TreeSkeleton} skeleton
+ * @param {import("../config/TreeSpeciesConfig.js").TreeSpeciesConfig} species
+ * @param {import("../mesh/foliage_collect_attachments.js").FoliageAttachmentSet} attachments
+ * @param {number} side_area m^2
+ * @param {number} lod_count
+ * @param {Map<number, ReturnType<typeof tree_mesh_compute_branch_rings>>} [planned] the bark's rings the caller has
+ *        already planned (`tree_mesh_compute_branch_rings`), by error: the search takes them rather than planning them
+ *        again
+ * @returns {TreeLODPlan[]}
+ */
+export function tree_lod_plan(skeleton, species, attachments, side_area, lod_count, planned = new Map()) {
+    const ceiling = TREE_RENDER_COST_CEILING;
+    const rigged = species.wind.enabled;
+    const drawn = new Map();
+    const at = (error) => {
+        let d = drawn.get(error);
+        if (d === undefined) {
+            const rings = planned.get(error) ?? tree_mesh_compute_branch_rings(skeleton, species, { error });
+            d = { rings, density: triangles_of(skeleton, attachments, rings) / side_area };
+            drawn.set(error, d);
+        }
+        return d;
+    };
+    /** @type {TreeLODPlan[]} */
+    const plan = [];
+    let error = TREE_LOD_ERROR_FINEST;
+    let finer = null;
+    for (let k = 0; k < lod_count; k++) {
+        const triangle_ceiling = ceiling.triangle_density[Math.min(k, ceiling.triangle_density.length - 1)];
+        for (; ;) {
+            const d = at(error);
+            const last = d.rings.size === 0;
+            if (d.density <= triangle_ceiling || last) {
+                const skin_info = tree_skeleton_assign_skin_joints(skeleton, species, {
+                    tolerance: Math.max(species.wind.deflection_tolerance, error),
+                    rings: d.rings,
+                    within: finer !== null ? finer.joint_vertex_ids : null
+                });
+                if (!rigged || skin_info.joint_count / side_area <= ceiling.joint_density || last) {
+                    plan.push({ error, skin_info });
+                    finer = skin_info;
+                    break;
+                }
+            }
+            error *= ERROR_STEP;
+        }
+    }
+    return plan;
+}

package/src/generation/foliage/config/BranchGeneratorConfig.d.ts

@@ -14,16 +14,6 @@ export class BranchGeneratorConfig {
      * @type {number}
      */
     segments: number;
-    /**
-     * Maximum radial vertices around the branch base (>= 3).
-     * @type {number}
-     */
-    radial_segments_max: number;
-    /**
-     * Minimum radial vertices at the branch tip (>= 3).
-     * @type {number}
-     */
-    radial_segments_min: number;
     /**
      * Nominal length in meters (scaled per child by the spawning rule's `length_profile`).
      * @type {number}

package/src/generation/foliage/config/BranchGeneratorConfig.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BranchGeneratorConfig.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/config/BranchGeneratorConfig.js"],"names":[],"mappings":"AAMA;;;;GAIG;AACH;IAmRI;;;OAGG;IACH,sBAHW,QAAQ,qBAAqB,CAAC,GAC5B,qBAAqB,CAMjC;IA1RD;;;OAGG;IACH,UAFU,MAAM,CAEH;IAEb;;;OAGG;IACH,qBAFU,MAAM,CAES;IAEzB;;;OAGG;IACH,qBAFU,MAAM,CAEQ;IAExB;;;OAGG;IACH,QAFU,MAAM,CAEH;IAEb;;;OAGG;IACH,iBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,cAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,OAFU,MAAM,CAEH;IAEb;;;OAGG;IACH,gBAFU,cAAc,CAE8B;IAEtD;;;OAGG;IACH,WAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,YAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,cAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,cAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,cAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,gBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,iBAFU,MAAM,CAEO;IAEvB;;;OAGG;IACH,mBAFU,MAAM,CAEQ;IAExB;;;OAGG;IACH,aAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,aAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,iBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,oBAFU,MAAM,CAEU;IAE1B;;;OAGG;IACH,aAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,iBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,iBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,iBAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,mBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,qBAFU,MAAM,CAEW;IAE3B;;;OAGG;IACH,qBAFU,MAAM,CAEW;IAE3B;;;OAGG;IACH,qBAFU,MAAM,CAEW;IAE3B;;;OAGG;IACH,qBAFU,MAAM,CAEW;IAE3B;;;OAGG;IACH,YAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,qBAFU,MAAM,CAEW;IAE3B;;;OAGG;IACH,kBAFU,MAAM,CAEQ;IAExB;;;OAGG;IACH,gBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,YAFU,MAAM,CAEE;IAElB;;;;;;;;;;;;;;OAcG;IACH,eAFU,MAAM,CAEI;IAEpB;;;;;OAKG;IACH,cAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,mBAFU,MAAM,CAES;IAEzB;;;OAGG;IACH,mBAFU,MAAM,CAES;IAEzB;;;;OAIG;IACH,qBAFU,MAAM,CAEW;IAE3B;;;;OAIG;IACH,WAFU,OAAO,CAEC;IAElB;;;;;;OAMG;IACH,MAFU,OAAO,CAEJ;IAEb;;;;;;;OAOG;IACH,cAFU,MAAM,CAEG;IAYnB;;;OAGG;IACH,2BAHW,QAAQ,qBAAqB,CAAC,GAC5B,IAAI,CAoDhB;IAED;;;OAGG;IACH,YAHW,qBAAqB,GACnB,IAAI,CA+ChB;IAED;;OAEG;IACH,SAFa,qBAAqB,CAMjC;IAED;;;OAGG;IACH,cAHW,qBAAqB,GACnB,OAAO,CA+CnB;IAED;;OAEG;IACH,QAFa,MAAM,CAqBlB;IAGL;;;OAGG;IACH,kCAFU,OAAO,CAEsC;CANtD;+BAle8B,mDAAmD"}
+{"version":3,"file":"BranchGeneratorConfig.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/config/BranchGeneratorConfig.js"],"names":[],"mappings":"AAMA;;;;GAIG;AACH;IAuQI;;;OAGG;IACH,sBAHW,QAAQ,qBAAqB,CAAC,GAC5B,qBAAqB,CAMjC;IA9QD;;;OAGG;IACH,UAFU,MAAM,CAEH;IAEb;;;OAGG;IACH,QAFU,MAAM,CAEH;IAEb;;;OAGG;IACH,iBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,cAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,OAFU,MAAM,CAEH;IAEb;;;OAGG;IACH,gBAFU,cAAc,CAE8B;IAEtD;;;OAGG;IACH,WAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,YAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,cAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,cAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,cAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,gBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,iBAFU,MAAM,CAEO;IAEvB;;;OAGG;IACH,mBAFU,MAAM,CAEQ;IAExB;;;OAGG;IACH,aAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,aAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,iBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,oBAFU,MAAM,CAEU;IAE1B;;;OAGG;IACH,aAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,iBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,iBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,iBAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,mBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,qBAFU,MAAM,CAEW;IAE3B;;;OAGG;IACH,qBAFU,MAAM,CAEW;IAE3B;;;OAGG;IACH,qBAFU,MAAM,CAEW;IAE3B;;;OAGG;IACH,qBAFU,MAAM,CAEW;IAE3B;;;OAGG;IACH,YAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,qBAFU,MAAM,CAEW;IAE3B;;;OAGG;IACH,kBAFU,MAAM,CAEQ;IAExB;;;OAGG;IACH,gBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,YAFU,MAAM,CAEE;IAElB;;;;;;;;;;;;;;OAcG;IACH,eAFU,MAAM,CAEI;IAEpB;;;;;OAKG;IACH,cAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,mBAFU,MAAM,CAES;IAEzB;;;OAGG;IACH,mBAFU,MAAM,CAES;IAEzB;;;;OAIG;IACH,qBAFU,MAAM,CAEW;IAE3B;;;;OAIG;IACH,WAFU,OAAO,CAEC;IAElB;;;;;;OAMG;IACH,MAFU,OAAO,CAEJ;IAEb;;;;;;;OAOG;IACH,cAFU,MAAM,CAEG;IAYnB;;;OAGG;IACH,2BAHW,QAAQ,qBAAqB,CAAC,GAC5B,IAAI,CA+ChB;IAED;;;OAGG;IACH,YAHW,qBAAqB,GACnB,IAAI,CA6ChB;IAED;;OAEG;IACH,SAFa,qBAAqB,CAMjC;IAED;;;OAGG;IACH,cAHW,qBAAqB,GACnB,OAAO,CA6CnB;IAED;;OAEG;IACH,QAFa,MAAM,CAoBlB;IAGL;;;OAGG;IACH,kCAFU,OAAO,CAEsC;CANtD;+BA5c8B,mDAAmD"}

package/src/generation/foliage/config/BranchGeneratorConfig.js

@@ -16,18 +16,6 @@ export class BranchGeneratorConfig {
      */
     segments = 8;
 
-    /**
-     * Maximum radial vertices around the branch base (>= 3).
-     * @type {number}
-     */
-    radial_segments_max = 12;
-
-    /**
-     * Minimum radial vertices at the branch tip (>= 3).
-     * @type {number}
-     */
-    radial_segments_min = 4;
-
     /**
      * Nominal length in meters (scaled per child by the spawning rule's `length_profile`).
      * @type {number}
@@ -303,11 +291,6 @@ export class BranchGeneratorConfig {
             return this;
         }
         if (overrides.segments !== undefined) this.segments = Math.max(1, overrides.segments | 0);
-        if (overrides.radial_segments_max !== undefined) this.radial_segments_max = Math.max(3, overrides.radial_segments_max | 0);
-        if (overrides.radial_segments_min !== undefined) this.radial_segments_min = Math.max(3, overrides.radial_segments_min | 0);
-        if (this.radial_segments_max < this.radial_segments_min) {
-            this.radial_segments_max = this.radial_segments_min;
-        }
         if (overrides.length !== undefined) this.length = overrides.length;
         if (overrides.length_variance !== undefined) this.length_variance = overrides.length_variance;
         if (overrides.radius_ratio !== undefined) this.radius_ratio = overrides.radius_ratio;
@@ -357,8 +340,6 @@ export class BranchGeneratorConfig {
     copy(other) {
         assert.defined(other, 'other');
         this.segments = other.segments;
-        this.radial_segments_max = other.radial_segments_max;
-        this.radial_segments_min = other.radial_segments_min;
         this.length = other.length;
         this.length_variance = other.length_variance;
         this.radius_ratio = other.radius_ratio;
@@ -418,8 +399,6 @@ export class BranchGeneratorConfig {
         if (this === other) return true;
         if (!other || !other.isBranchGeneratorConfig) return false;
         return this.segments === other.segments
-            && this.radial_segments_max === other.radial_segments_max
-            && this.radial_segments_min === other.radial_segments_min
             && this.length === other.length
             && this.length_variance === other.length_variance
             && this.radius_ratio === other.radius_ratio
@@ -465,8 +444,7 @@ export class BranchGeneratorConfig {
      * @returns {number}
      */
     hash() {
-        let h = hash_mix2(this.segments, this.radial_segments_max);
-        h = hash_mix2(h, this.radial_segments_min);
+        let h = this.segments;
         h = hash_mix2(h, computeHashFloat(this.length));
         h = hash_mix2(h, computeHashFloat(this.radius_ratio));
         h = hash_mix2(h, computeHashFloat(this.taper));