@woosh/meep-engine 3.56.0 → 3.58.0

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

@@ -3,10 +3,14 @@ import { hash_mix2 } from "../../../core/math/hash/hash_mix2.js";
 import { computeStringHash } from "../../../core/primitives/strings/computeStringHash.js";
 import { AnimationCurve } from "../../../engine/animation/curve/AnimationCurve.js";
 import { BarkMaterialConfig } from "./BarkMaterialConfig.js";
-import { BranchLevelConfig } from "./BranchLevelConfig.js";
+import { BranchGeneratorConfig } from "./BranchGeneratorConfig.js";
+import { BranchSpawnRule } from "./BranchSpawnRule.js";
 import { CrownConfig } from "./CrownConfig.js";
 import { FoliageConfig } from "./FoliageConfig.js";
 import { FoliageMaterialConfig } from "./FoliageMaterialConfig.js";
+import { FoliageSpawnRule } from "./FoliageSpawnRule.js";
+import { ShootGrowthConfig } from "./ShootGrowthConfig.js";
+import { ShootSystemRule } from "./ShootSystemRule.js";
 import { TreeLODConfig } from "./TreeLODConfig.js";
 import { TreePreset } from "./TreePreset.js";
 import { TreeWindConfig } from "./TreeWindConfig.js";
@@ -40,17 +44,45 @@ export class TreeSpeciesConfig {
     crown = new CrownConfig();
 
     /**
-     * Recursive branch level configurations (`levels[0]` = trunk, `levels[1]` = boughs, etc.).
-     * @type {BranchLevelConfig[]}
+     * Branch generators. `branches[0]` grows the trunk; every other generator grows only where a
+     * `branch_rules` entry targets it.
+     * @type {BranchGeneratorConfig[]}
      */
-    levels = [];
+    branches = [];
 
     /**
-     * Phyllotactic foliage card placement and geometry configuration.
+     * Edges of the generator graph: which generator spawns which, where and how many.
+     * Each rule has `source < target`, so the graph is acyclic and the trunk is its only root.
+     * @type {BranchSpawnRule[]}
+     */
+    branch_rules = [];
+
+    /**
+     * Leaf card / frond geometry shared by all foliage of the tree.
      * @type {FoliageConfig}
      */
     foliage = new FoliageConfig();
 
+    /**
+     * Which branch generators carry foliage. How densely is derived (`foliage_cards_per_metre`). Empty = a bare tree.
+     * @type {FoliageSpawnRule[]}
+     */
+    foliage_rules = [];
+
+    /**
+     * Which branch generators carry a peripheral twig system grown year by year from their buds, and which generator
+     * its shoots are (`tree_skeleton_grow_shoots`). Empty = none.
+     * @type {ShootSystemRule[]}
+     */
+    shoot_rules = [];
+
+    /**
+     * How the shoot systems of `shoot_rules` grow together: the tree's age, its leader, and their vigour in the light they
+     * make for each other.
+     * @type {ShootGrowthConfig}
+     */
+    shoot_growth = new ShootGrowthConfig();
+
     /**
      * Procedural bark PBR material configuration.
      * @type {BarkMaterialConfig}
@@ -83,30 +115,52 @@ export class TreeSpeciesConfig {
     trunk_guide = null;
 
     constructor() {
-        this.levels = TreeSpeciesConfig.createDefaultLevels();
+        this.branches = TreeSpeciesConfig.createDefaultBranches();
+        this.branch_rules = TreeSpeciesConfig.createDefaultBranchRules();
+        this.foliage_rules = [FoliageSpawnRule.from({ source: 2 })];
         this.lods = TreeLODConfig.createDefaultChain(3);
     }
 
     /**
-     * Creates a default 3-level branch hierarchy (trunk, primary boughs, secondary branches).
-     * @returns {BranchLevelConfig[]}
+     * Default trunk -> primary bough -> secondary branch spawning.
+     * @returns {BranchSpawnRule[]}
+     */
+    static createDefaultBranchRules() {
+        return [
+            BranchSpawnRule.from({
+                source: 0,
+                target: 1,
+                count: 11,
+                attach_min: 0.30,
+                insertion_angle: 1.18,
+                insertion_angle_variation: 0.14,
+                insertion_angle_profile: AnimationCurve.linear(0, 1.05, 1, 0.52),
+                length_profile: AnimationCurve.linear(0, 1.0, 1, 0.52)
+            }),
+            BranchSpawnRule.from({
+                source: 1,
+                target: 2,
+                count: 8,
+                attach_min: 0.18,
+                insertion_angle: 0.82,
+                insertion_angle_variation: 0.16,
+                length_profile: AnimationCurve.linear(0, 0.9, 1, 0.5)
+            })
+        ];
+    }
+
+    /**
+     * Default branch generators: trunk, primary boughs, secondary branches.
+     * @returns {BranchGeneratorConfig[]}
      */
-    static createDefaultLevels() {
+    static createDefaultBranches() {
         return [
-            BranchLevelConfig.from({
-                level: 0,
+            BranchGeneratorConfig.from({
                 segments: 12,
-                radial_segments_max: 14,
-                radial_segments_min: 8,
                 length: 9.0,
                 length_variance: 0.06,
                 radius_ratio: 0.058,
                 taper: 0.78,
-                bare_length_ratio: 0.30,
-                child_count: 11,
-                insertion_angle: 1.18,
-                insertion_angle_variation: 0.14,
-                insertion_angle_profile: AnimationCurve.linear(0, 1.05, 1, 0.52),
                 curvature: 0.22,
                 curve_back: -0.14,
                 spiral_twist: 0.35,
@@ -122,8 +176,6 @@ export class TreeSpeciesConfig {
                 oval_eccentricity: 0.10,
                 bark_displacement: 0.10,
                 parent_collar_bulge: 0.34,
-                knot_count: 6,
-                knot_strength: 0.18,
                 split_probability: 0.32,
                 split_count: 2,
                 split_angle: 0.52,
@@ -135,20 +187,12 @@ export class TreeSpeciesConfig {
                 flute_frequency: 4,
                 collar_weld_rings: 0
             }),
-            BranchLevelConfig.from({
-                level: 1,
+            BranchGeneratorConfig.from({
                 segments: 8,
-                radial_segments_max: 9,
-                radial_segments_min: 5,
                 length: 5.2,
                 length_variance: 0.14,
-                length_profile: AnimationCurve.linear(0, 1.0, 1, 0.52),
                 radius_ratio: 0.046,
                 taper: 0.82,
-                bare_length_ratio: 0.18,
-                child_count: 8,
-                insertion_angle: 0.82,
-                insertion_angle_variation: 0.16,
                 curvature: -0.22,
                 curve_back: 0.18,
                 spiral_twist: 0.28,
@@ -164,8 +208,6 @@ export class TreeSpeciesConfig {
                 oval_eccentricity: 0.20,
                 bark_displacement: 0.08,
                 parent_collar_bulge: 0.28,
-                knot_count: 3,
-                knot_strength: 0.14,
                 split_probability: 0.26,
                 split_count: 2,
                 split_angle: 0.48,
@@ -177,20 +219,12 @@ export class TreeSpeciesConfig {
                 collar_spread_lower: 0.45,
                 collar_normal_blend: 0.85
             }),
-            BranchLevelConfig.from({
-                level: 2,
+            BranchGeneratorConfig.from({
                 segments: 6,
-                radial_segments_max: 6,
-                radial_segments_min: 4,
                 length: 2.1,
                 length_variance: 0.18,
-                length_profile: AnimationCurve.linear(0, 0.9, 1, 0.5),
                 radius_ratio: 0.036,
                 taper: 0.88,
-                bare_length_ratio: 0.12,
-                child_count: 0,
-                insertion_angle: 0.68,
-                insertion_angle_variation: 0.18,
                 curvature: 0.22,
                 curve_back: -0.12,
                 gravitropism: 0.12,
@@ -203,8 +237,6 @@ export class TreeSpeciesConfig {
                 tip_upcurl: 0.32,
                 oval_eccentricity: 0.12,
                 bark_displacement: 0.05,
-                knot_count: 1,
-                knot_strength: 0.08,
                 collar_weld_rings: 1,
                 collar_length_ratio: 0.12,
                 collar_spread_upper: 0.18,
@@ -246,33 +278,23 @@ export class TreeSpeciesConfig {
         if (overrides.foliage_material !== undefined) this.foliage_material.applyOverrides(overrides.foliage_material);
         if (overrides.wind !== undefined) this.wind.applyOverrides(overrides.wind);
 
-        if (Array.isArray(overrides.levels)) {
-            if (overrides.replace_levels === true) {
-                this.levels = overrides.levels.map((lvl, idx) => {
-                    const base = BranchLevelConfig.from(lvl);
-                    base.level = idx;
-                    return base;
-                });
-            } else if (overrides.levels.length !== this.levels.length) {
-                this.levels = overrides.levels.map((lvl, idx) => {
-                    const existing = this.levels[idx];
-                    const base = existing && existing.isBranchLevelConfig ? existing.clone() : new BranchLevelConfig();
-                    base.level = idx;
-                    base.applyOverrides(lvl);
-                    return base;
-                });
-            } else {
-                for (let i = 0; i < overrides.levels.length; i++) {
-                    if (overrides.levels[i]) {
-                        if (!this.levels[i] || !this.levels[i].isBranchLevelConfig) {
-                            this.levels[i] = new BranchLevelConfig();
-                        }
-                        this.levels[i].applyOverrides(overrides.levels[i]);
-                        this.levels[i].level = i;
-                    }
-                }
-            }
+        if (Array.isArray(overrides.branches)) {
+            this.branches = overrides.branches.map(b => BranchGeneratorConfig.from(b));
+            // rules index generators: a new generator list invalidates the old ones unless they come with it
+            this.branch_rules = [];
+            this.foliage_rules = [];
+            this.shoot_rules = [];
         }
+        if (Array.isArray(overrides.branch_rules)) {
+            this.branch_rules = overrides.branch_rules.map(r => BranchSpawnRule.from(r));
+        }
+        if (Array.isArray(overrides.foliage_rules)) {
+            this.foliage_rules = overrides.foliage_rules.map(r => FoliageSpawnRule.from(r));
+        }
+        if (Array.isArray(overrides.shoot_rules)) {
+            this.shoot_rules = overrides.shoot_rules.map(r => ShootSystemRule.from(r));
+        }
+        if (overrides.shoot_growth !== undefined) this.shoot_growth.applyOverrides(overrides.shoot_growth);
 
         if (overrides.lod_count !== undefined && overrides.lods === undefined) {
             this.lods = TreeLODConfig.createDefaultChain(overrides.lod_count);
@@ -300,8 +322,12 @@ export class TreeSpeciesConfig {
             ? other.trunk_guide.map(pt => [pt[0], pt[1], pt[2]])
             : other.trunk_guide;
         this.crown.copy(other.crown);
-        this.levels = other.levels.map(l => l.clone());
+        this.branches = other.branches.map(b => b.clone());
+        this.branch_rules = other.branch_rules.map(r => r.clone());
         this.foliage.copy(other.foliage);
+        this.foliage_rules = other.foliage_rules.map(r => r.clone());
+        this.shoot_rules = other.shoot_rules.map(r => r.clone());
+        this.shoot_growth.copy(other.shoot_growth);
         this.bark_material.copy(other.bark_material);
         this.foliage_material.copy(other.foliage_material);
         this.wind.copy(other.wind);
@@ -352,11 +378,26 @@ export class TreeSpeciesConfig {
         ) {
             return false;
         }
-        if (this.levels.length !== other.levels.length || this.lods.length !== other.lods.length) {
+        if (this.branches.length !== other.branches.length
+            || this.branch_rules.length !== other.branch_rules.length
+            || this.foliage_rules.length !== other.foliage_rules.length
+            || this.shoot_rules.length !== other.shoot_rules.length
+            || !this.shoot_growth.equals(other.shoot_growth)
+            || this.lods.length !== other.lods.length
+        ) {
             return false;
         }
-        for (let i = 0; i < this.levels.length; i++) {
-            if (!this.levels[i].equals(other.levels[i])) return false;
+        for (let i = 0; i < this.branches.length; i++) {
+            if (!this.branches[i].equals(other.branches[i])) return false;
+        }
+        for (let i = 0; i < this.branch_rules.length; i++) {
+            if (!this.branch_rules[i].equals(other.branch_rules[i])) return false;
+        }
+        for (let i = 0; i < this.foliage_rules.length; i++) {
+            if (!this.foliage_rules[i].equals(other.foliage_rules[i])) return false;
+        }
+        for (let i = 0; i < this.shoot_rules.length; i++) {
+            if (!this.shoot_rules[i].equals(other.shoot_rules[i])) return false;
         }
         for (let i = 0; i < this.lods.length; i++) {
             if (!this.lods[i].equals(other.lods[i])) return false;
@@ -383,9 +424,19 @@ export class TreeSpeciesConfig {
         h = hash_mix2(h, this.bark_material.hash());
         h = hash_mix2(h, this.foliage_material.hash());
         h = hash_mix2(h, this.wind.hash());
-        for (let i = 0; i < this.levels.length; i++) {
-            h = hash_mix2(h, this.levels[i].hash());
+        for (let i = 0; i < this.branches.length; i++) {
+            h = hash_mix2(h, this.branches[i].hash());
+        }
+        for (let i = 0; i < this.branch_rules.length; i++) {
+            h = hash_mix2(h, this.branch_rules[i].hash());
+        }
+        for (let i = 0; i < this.foliage_rules.length; i++) {
+            h = hash_mix2(h, this.foliage_rules[i].hash());
+        }
+        for (let i = 0; i < this.shoot_rules.length; i++) {
+            h = hash_mix2(h, this.shoot_rules[i].hash());
         }
+        h = hash_mix2(h, this.shoot_growth.hash());
         for (let i = 0; i < this.lods.length; i++) {
             h = hash_mix2(h, this.lods[i].hash());
         }

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

@@ -1,3 +1,9 @@
+/**
+ * Wind speed (m/s) the trees are tuned to look right in: `TreeWindConfig.elastic_modulus` is fitted at it, and joints
+ * are placed for the sway it causes (`tree_skeleton_assign_skin_joints`).
+ * @type {number}
+ */
+export const TREE_WIND_REFERENCE_SPEED: number;
 /**
  * Configuration for GPU fluid-driven skeletal wind animation (`Skin` + `FoliageWindRig`)
  * and per-vertex wind attributes.
@@ -18,25 +24,32 @@ export class TreeWindConfig {
      */
     enabled: boolean;
     /**
-     * Maximum number of structural skeleton joints extracted for `Skin` and `FoliageWindRig` (>= 1).
+     * Safety net on the number of joints extracted for `Skin` and `FoliageWindRig` (1 to 65,536, joint indices are
+     * 16-bit). The count itself is derived from the tree (`deflection_tolerance`); past the cap, the joints that would
+     * hide the least sway are dropped. 65,536 is the most 16-bit joint indices hold.
      * @type {number}
      */
     max_joints: number;
     /**
-     * Baseline aerodynamic compliance (rad / (m/s)^2) for level-0 trunk joints.
-     * @type {number}
-     */
-    trunk_compliance: number;
-    /**
-     * Baseline aerodynamic compliance (rad / (m/s)^2) for primary and secondary branch joints.
+     * Deflection (m) a rigid piece of the wind rig may hide in the reference wind (`TREE_WIND_REFERENCE_SPEED`): joints
+     * go wherever leaving the wood rigid would misplace part of the tree by more than this
+     * (`tree_skeleton_assign_skin_joints`). Smaller takes more joints, `Infinity` none. 0.01 m is a chosen number.
      * @type {number}
      */
-    branch_compliance: number;
+    deflection_tolerance: number;
     /**
-     * Baseline natural angular frequency omega_0 (rad/s) for structural branches.
+     * Effective Young's modulus (Pa) of the tree's wood in bending, from which every joint's wind compliance and
+     * natural frequency follow (`tree_skeleton_compute_joint_mechanics`). Green wood is ~8 GPa, but generated
+     * stems are thicker for their length than real ones, so that value leaves them nearly still. This one is fitted
+     * to keep the oak preset's boughs at the sway they were tuned to in a `TREE_WIND_REFERENCE_SPEED` wind. It was
+     * refitted from 2.42e8 to 3.33e7 when the foliage sail became the derived leaf area, and to 4.55e7 when the oak grew
+     * its twig layer (`shoot_rules`) and each segment began to bend under its own load: the median of its primary
+     * boughs' compliance, each bent as one cantilever over 12 seeds, is back at its value before (ratio 0.999). One
+     * modulus cannot hold every preset's old sway: against theirs before that refit, maple boughs move 1.12x, pine 1.14x
+     * and birch 1.04x.
      * @type {number}
      */
-    natural_frequency: number;
+    elastic_modulus: number;
     /**
      * Dimensionless viscous + structural damping ratio zeta (0 < zeta < 1 is underdamped).
      * @type {number}

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

@@ -1 +1 @@
-{"version":3,"file":"TreeWindConfig.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/config/TreeWindConfig.js"],"names":[],"mappings":"AAIA;;;;;;;GAOG;AACH;IAiDI;;;OAGG;IACH,sBAHW,QAAQ,cAAc,CAAC,GAAC,OAAO,GAC7B,cAAc,CAM1B;IAxDD;;;OAGG;IACH,SAFU,OAAO,CAEF;IAEf;;;OAGG;IACH,YAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,kBAFU,MAAM,CAES;IAEzB;;;OAGG;IACH,mBAFU,MAAM,CAEU;IAE1B;;;OAGG;IACH,mBAFU,MAAM,CAEQ;IAExB;;;OAGG;IACH,eAFU,MAAM,CAEK;IAErB;;;OAGG;IACH,YAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,gBAFU,MAAM,CAEM;IAYtB;;;OAGG;IACH,2BAHW,QAAQ,cAAc,CAAC,GAAC,OAAO,GAC7B,IAAI,CAmBhB;IAED;;;OAGG;IACH,YAHW,cAAc,GACZ,IAAI,CAahB;IAED;;OAEG;IACH,SAFa,cAAc,CAM1B;IAED;;;OAGG;IACH,cAHW,cAAc,GACZ,OAAO,CAanB;IAED;;OAEG;IACH,QAFa,MAAM,CAWlB;IAGL;;;OAGG;IACH,2BAFU,OAAO,CAEwB;CANxC"}
+{"version":3,"file":"TreeWindConfig.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/config/TreeWindConfig.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,wCAFU,MAAM,CAE6B;AAE7C;;;;;;;GAOG;AACH;IAuDI;;;OAGG;IACH,sBAHW,QAAQ,cAAc,CAAC,GAAC,OAAO,GAC7B,cAAc,CAM1B;IA9DD;;;OAGG;IACH,SAFU,OAAO,CAEF;IAEf;;;;;OAKG;IACH,YAFU,MAAM,CAEG;IAEnB;;;;;OAKG;IACH,sBAFU,MAAM,CAEY;IAE5B;;;;;;;;;;;OAWG;IACH,iBAFU,MAAM,CAES;IAEzB;;;OAGG;IACH,eAFU,MAAM,CAEK;IAErB;;;OAGG;IACH,YAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,gBAFU,MAAM,CAEM;IAYtB;;;OAGG;IACH,2BAHW,QAAQ,cAAc,CAAC,GAAC,OAAO,GAC7B,IAAI,CAkBhB;IAED;;;OAGG;IACH,YAHW,cAAc,GACZ,IAAI,CAYhB;IAED;;OAEG;IACH,SAFa,cAAc,CAM1B;IAED;;;OAGG;IACH,cAHW,cAAc,GACZ,OAAO,CAYnB;IAED;;OAEG;IACH,QAFa,MAAM,CAUlB;IAGL;;;OAGG;IACH,2BAFU,OAAO,CAEwB;CANxC"}

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

@@ -2,6 +2,13 @@ import { assert } from "../../../core/assert.js";
 import { hash_mix2 } from "../../../core/math/hash/hash_mix2.js";
 import { computeHashFloat } from "../../../core/primitives/numbers/computeHashFloat.js";
 
+/**
+ * Wind speed (m/s) the trees are tuned to look right in: `TreeWindConfig.elastic_modulus` is fitted at it, and joints
+ * are placed for the sway it causes (`tree_skeleton_assign_skin_joints`).
+ * @type {number}
+ */
+export const TREE_WIND_REFERENCE_SPEED = 6.5;
+
 /**
  * Configuration for GPU fluid-driven skeletal wind animation (`Skin` + `FoliageWindRig`)
  * and per-vertex wind attributes.
@@ -18,28 +25,34 @@ export class TreeWindConfig {
     enabled = true;
 
     /**
-     * Maximum number of structural skeleton joints extracted for `Skin` and `FoliageWindRig` (>= 1).
-     * @type {number}
-     */
-    max_joints = 32;
-
-    /**
-     * Baseline aerodynamic compliance (rad / (m/s)^2) for level-0 trunk joints.
+     * Safety net on the number of joints extracted for `Skin` and `FoliageWindRig` (1 to 65,536, joint indices are
+     * 16-bit). The count itself is derived from the tree (`deflection_tolerance`); past the cap, the joints that would
+     * hide the least sway are dropped. 65,536 is the most 16-bit joint indices hold.
      * @type {number}
      */
-    trunk_compliance = 0.012;
+    max_joints = 65536;
 
     /**
-     * Baseline aerodynamic compliance (rad / (m/s)^2) for primary and secondary branch joints.
+     * Deflection (m) a rigid piece of the wind rig may hide in the reference wind (`TREE_WIND_REFERENCE_SPEED`): joints
+     * go wherever leaving the wood rigid would misplace part of the tree by more than this
+     * (`tree_skeleton_assign_skin_joints`). Smaller takes more joints, `Infinity` none. 0.01 m is a chosen number.
      * @type {number}
      */
-    branch_compliance = 0.045;
+    deflection_tolerance = 0.01;
 
     /**
-     * Baseline natural angular frequency omega_0 (rad/s) for structural branches.
+     * Effective Young's modulus (Pa) of the tree's wood in bending, from which every joint's wind compliance and
+     * natural frequency follow (`tree_skeleton_compute_joint_mechanics`). Green wood is ~8 GPa, but generated
+     * stems are thicker for their length than real ones, so that value leaves them nearly still. This one is fitted
+     * to keep the oak preset's boughs at the sway they were tuned to in a `TREE_WIND_REFERENCE_SPEED` wind. It was
+     * refitted from 2.42e8 to 3.33e7 when the foliage sail became the derived leaf area, and to 4.55e7 when the oak grew
+     * its twig layer (`shoot_rules`) and each segment began to bend under its own load: the median of its primary
+     * boughs' compliance, each bent as one cantilever over 12 seeds, is back at its value before (ratio 0.999). One
+     * modulus cannot hold every preset's old sway: against theirs before that refit, maple boughs move 1.12x, pine 1.14x
+     * and birch 1.04x.
      * @type {number}
      */
-    natural_frequency = 2.8;
+    elastic_modulus = 4.55e7;
 
     /**
      * Dimensionless viscous + structural damping ratio zeta (0 < zeta < 1 is underdamped).
@@ -82,10 +95,9 @@ export class TreeWindConfig {
             return this;
         }
         if (overrides.enabled !== undefined) this.enabled = Boolean(overrides.enabled);
-        if (overrides.max_joints !== undefined) this.max_joints = Math.max(1, overrides.max_joints | 0);
-        if (overrides.trunk_compliance !== undefined) this.trunk_compliance = Math.max(0, overrides.trunk_compliance);
-        if (overrides.branch_compliance !== undefined) this.branch_compliance = Math.max(0, overrides.branch_compliance);
-        if (overrides.natural_frequency !== undefined) this.natural_frequency = Math.max(0.1, overrides.natural_frequency);
+        if (overrides.max_joints !== undefined) this.max_joints = Math.min(65536, Math.max(1, overrides.max_joints | 0));
+        if (overrides.deflection_tolerance !== undefined) this.deflection_tolerance = Math.max(0, overrides.deflection_tolerance);
+        if (overrides.elastic_modulus !== undefined) this.elastic_modulus = Math.max(1.0, overrides.elastic_modulus);
         if (overrides.damping_ratio !== undefined) this.damping_ratio = Math.max(0.01, overrides.damping_ratio);
         if (overrides.turbulence !== undefined) this.turbulence = Math.max(0, overrides.turbulence);
         if (overrides.max_bend_angle !== undefined) this.max_bend_angle = Math.max(0.01, overrides.max_bend_angle);
@@ -100,9 +112,8 @@ export class TreeWindConfig {
         assert.defined(other, 'other');
         this.enabled = other.enabled;
         this.max_joints = other.max_joints;
-        this.trunk_compliance = other.trunk_compliance;
-        this.branch_compliance = other.branch_compliance;
-        this.natural_frequency = other.natural_frequency;
+        this.deflection_tolerance = other.deflection_tolerance;
+        this.elastic_modulus = other.elastic_modulus;
         this.damping_ratio = other.damping_ratio;
         this.turbulence = other.turbulence;
         this.max_bend_angle = other.max_bend_angle;
@@ -127,9 +138,8 @@ export class TreeWindConfig {
         if (!other || !other.isTreeWindConfig) return false;
         return this.enabled === other.enabled
             && this.max_joints === other.max_joints
-            && this.trunk_compliance === other.trunk_compliance
-            && this.branch_compliance === other.branch_compliance
-            && this.natural_frequency === other.natural_frequency
+            && this.deflection_tolerance === other.deflection_tolerance
+            && this.elastic_modulus === other.elastic_modulus
             && this.damping_ratio === other.damping_ratio
             && this.turbulence === other.turbulence
             && this.max_bend_angle === other.max_bend_angle;
@@ -140,9 +150,8 @@ export class TreeWindConfig {
      */
     hash() {
         let h = hash_mix2(this.enabled ? 1 : 0, this.max_joints);
-        h = hash_mix2(h, computeHashFloat(this.trunk_compliance));
-        h = hash_mix2(h, computeHashFloat(this.branch_compliance));
-        h = hash_mix2(h, computeHashFloat(this.natural_frequency));
+        h = hash_mix2(h, computeHashFloat(this.deflection_tolerance));
+        h = hash_mix2(h, computeHashFloat(this.elastic_modulus));
         h = hash_mix2(h, computeHashFloat(this.damping_ratio));
         h = hash_mix2(h, computeHashFloat(this.turbulence));
         h = hash_mix2(h, computeHashFloat(this.max_bend_angle));

package/src/generation/foliage/index.d.ts

@@ -3,11 +3,18 @@ export { PhyllotaxisMode } from "./config/PhyllotaxisMode.js";
 export { FoliageCardType } from "./config/FoliageCardType.js";
 export { FoliageBarkType } from "./config/FoliageBarkType.js";
 export { TreePreset } from "./config/TreePreset.js";
-export { BranchLevelConfig } from "./config/BranchLevelConfig.js";
+export { BranchGeneratorConfig } from "./config/BranchGeneratorConfig.js";
+export { BranchSpawnRule } from "./config/BranchSpawnRule.js";
+export { FoliageSpawnRule } from "./config/FoliageSpawnRule.js";
 export { CrownConfig } from "./config/CrownConfig.js";
 export { FoliageConfig } from "./config/FoliageConfig.js";
 export { BarkMaterialConfig } from "./config/BarkMaterialConfig.js";
 export { FoliageMaterialConfig } from "./config/FoliageMaterialConfig.js";
+export { FoliageTileContent } from "./config/FoliageTileContent.js";
+export { LeafArchitecture } from "./config/LeafArchitecture.js";
+export { LeafApexShape } from "./config/LeafApexShape.js";
+export { LeafBaseShape } from "./config/LeafBaseShape.js";
+export { LeafLobation } from "./config/LeafLobation.js";
 export { TreeWindConfig } from "./config/TreeWindConfig.js";
 export { TreeLODConfig } from "./config/TreeLODConfig.js";
 export { TreeSpeciesConfig } from "./config/TreeSpeciesConfig.js";
@@ -22,6 +29,10 @@ export { foliage_collect_attachments } from "./mesh/foliage_collect_attachments.
 export { tree_mesh_build_foliage } from "./mesh/tree_mesh_build_foliage.js";
 export { tree_mesh_apply_canopy_ao } from "./mesh/tree_mesh_apply_canopy_ao.js";
 export { make_bark_material } from "./material/make_bark_material.js";
+export { make_foliage_material } from "./material/make_foliage_material.js";
+export { compute_foliage_variant_atlas_layout } from "./material/compute_foliage_variant_atlas_layout.js";
+export { foliage_atlas_cutout } from "./material/foliage_atlas_cutout.js";
+export { foliage_measure_leaf_area } from "./analysis/foliage_measure_leaf_area.js";
 export { build_tree_wind_rig } from "./animation/build_tree_wind_rig.js";
 export { FoliageWindJoint } from "../../shade/renderer/animation/foliage/FoliageWindJoint.js";
 export { FoliageWindRig } from "../../shade/renderer/animation/foliage/FoliageWindRig.js";
@@ -31,9 +42,15 @@ export { FoliageWindSystem } from "../../engine/graphics3/FoliageWindSystem.js";
 export { TreeLODAsset } from "./asset/TreeLODAsset.js";
 export { TreeAsset } from "./asset/TreeAsset.js";
 export { generate_tree } from "./asset/generate_tree.js";
+export { CrownOpacity } from "./analysis/CrownOpacity.js";
+export { crown_opacity_measure } from "./analysis/crown_opacity_measure.js";
+export { crown_opacity_frames } from "./analysis/crown_opacity_frames.js";
+export { tree_crown_opacity } from "./analysis/tree_crown_opacity.js";
 export { crown_envelope_evaluate, crown_envelope_sdf } from "./skeleton/crown_envelope_evaluate.js";
 export { branch_ring_triangulate, branch_apex_triangulate } from "./mesh/branch_ring_triangulate.js";
 export { tree_mesh_build_bark, geometry_obtain_joints_attribute } from "./mesh/tree_mesh_build_bark.js";
-export { make_foliage_material, compute_foliage_variant_atlas_layout } from "./material/make_foliage_material.js";
+export { FoliageAtlasCutout, CUTOUT_HULL_VERTEX_COUNT } from "./material/FoliageAtlasCutout.js";
+export { foliage_tile_layout, foliage_tile_raster } from "./material/foliage_tile.js";
+export { leaf_geometry, needle_shoot_geometry } from "./material/leaf_geometry.js";
 export { place_tree, unplace_tree } from "./asset/place_tree.js";
 //# sourceMappingURL=index.d.ts.map