@woosh/meep-engine 3.51.0 → 3.53.0

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

@@ -0,0 +1,90 @@
+/**
+ * Procedural foliage cluster PBR material & silhouette synthesis configuration.
+ */
+export class FoliageMaterialConfig {
+    /**
+     * @param {Partial<FoliageMaterialConfig>} [options]
+     * @returns {FoliageMaterialConfig}
+     */
+    static from(options?: Partial<FoliageMaterialConfig>): FoliageMaterialConfig;
+    /**
+     * Procedural texture resolution (pixels, power of two).
+     * @type {number}
+     */
+    resolution: number;
+    /**
+     * Sun-facing leaf lamina color (sRGB).
+     * @type {Color}
+     */
+    primary_color: Color;
+    /**
+     * Vein / young tip / secondary leaf color (sRGB).
+     * @type {Color}
+     */
+    secondary_color: Color;
+    /**
+     * Autumn / golden-red shift factor [0, 1].
+     * @type {number}
+     */
+    autumn_tint: number;
+    /**
+     * Leaf cluster silhouette style: `"ovate" | "lobed" | "serrated" | "palmate" | "needle" | "frond"`.
+     * @type {string}
+     */
+    leaf_shape: string;
+    /**
+     * Number of leaflets arranged on the twig cluster card.
+     * @type {number}
+     */
+    leaflets_per_cluster: number;
+    /**
+     * Base PBR roughness [0, 1].
+     * @type {number}
+     */
+    roughness: number;
+    /**
+     * Venation normal-map relief strength [0, 1].
+     * @type {number}
+     */
+    vein_strength: number;
+    /**
+     * Horizontal UV coordinate [0, 1] on the foliage card where the drawn woody stem/petiole attaches to the branch.
+     * @type {number}
+     */
+    stem_anchor_u: number;
+    /**
+     * Vertical UV coordinate [0, 1] on the foliage card where the drawn woody stem/petiole attaches to the branch.
+     * @type {number}
+     */
+    stem_anchor_v: number;
+    /**
+     * @param {Partial<FoliageMaterialConfig>} [overrides]
+     * @returns {this}
+     */
+    applyOverrides(overrides?: Partial<FoliageMaterialConfig>): this;
+    /**
+     * @param {FoliageMaterialConfig} other
+     * @returns {this}
+     */
+    copy(other: FoliageMaterialConfig): this;
+    /**
+     * @returns {FoliageMaterialConfig}
+     */
+    clone(): FoliageMaterialConfig;
+    /**
+     * @param {FoliageMaterialConfig} other
+     * @returns {boolean}
+     */
+    equals(other: FoliageMaterialConfig): boolean;
+    /**
+     * @returns {number}
+     */
+    hash(): number;
+    /**
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isFoliageMaterialConfig: boolean;
+}
+import { Color } from "../../../core/color/Color.js";
+//# sourceMappingURL=FoliageMaterialConfig.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"FoliageMaterialConfig.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/config/FoliageMaterialConfig.js"],"names":[],"mappings":"AAMA;;GAEG;AACH;IA6DI;;;OAGG;IACH,sBAHW,QAAQ,qBAAqB,CAAC,GAC5B,qBAAqB,CAMjC;IApED;;;OAGG;IACH,YAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,eAFU,KAAK,CAEkC;IAEjD;;;OAGG;IACH,iBAFU,KAAK,CAEoC;IAEnD;;;OAGG;IACH,aAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,YAFU,MAAM,CAEK;IAErB;;;OAGG;IACH,sBAFU,MAAM,CAES;IAEzB;;;OAGG;IACH,WAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,eAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,eAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,eAFU,MAAM,CAEI;IAYpB;;;OAGG;IACH,2BAHW,QAAQ,qBAAqB,CAAC,GAC5B,IAAI,CA6BhB;IAED;;;OAGG;IACH,YAHW,qBAAqB,GACnB,IAAI,CAehB;IAED;;OAEG;IACH,SAFa,qBAAqB,CAMjC;IAED;;;OAGG;IACH,cAHW,qBAAqB,GACnB,OAAO,CAenB;IAED;;OAEG;IACH,QAFa,MAAM,CAYlB;IAGL;;;OAGG;IACH,kCAFU,OAAO,CAEsC;CANtD;sBA7KqB,8BAA8B"}

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

@@ -0,0 +1,181 @@
+import { assert } from "../../../core/assert.js";
+import { Color } from "../../../core/color/Color.js";
+import { hash_mix2 } from "../../../core/math/hash/hash_mix2.js";
+import { computeHashFloat } from "../../../core/primitives/numbers/computeHashFloat.js";
+import { computeStringHash } from "../../../core/primitives/strings/computeStringHash.js";
+
+/**
+ * Procedural foliage cluster PBR material & silhouette synthesis configuration.
+ */
+export class FoliageMaterialConfig {
+    /**
+     * Procedural texture resolution (pixels, power of two).
+     * @type {number}
+     */
+    resolution = 128;
+
+    /**
+     * Sun-facing leaf lamina color (sRGB).
+     * @type {Color}
+     */
+    primary_color = new Color(0.26, 0.48, 0.16, 1.0);
+
+    /**
+     * Vein / young tip / secondary leaf color (sRGB).
+     * @type {Color}
+     */
+    secondary_color = new Color(0.38, 0.58, 0.22, 1.0);
+
+    /**
+     * Autumn / golden-red shift factor [0, 1].
+     * @type {number}
+     */
+    autumn_tint = 0.0;
+
+    /**
+     * Leaf cluster silhouette style: `"ovate" | "lobed" | "serrated" | "palmate" | "needle" | "frond"`.
+     * @type {string}
+     */
+    leaf_shape = "lobed";
+
+    /**
+     * Number of leaflets arranged on the twig cluster card.
+     * @type {number}
+     */
+    leaflets_per_cluster = 5;
+
+    /**
+     * Base PBR roughness [0, 1].
+     * @type {number}
+     */
+    roughness = 0.56;
+
+    /**
+     * Venation normal-map relief strength [0, 1].
+     * @type {number}
+     */
+    vein_strength = 0.5;
+
+    /**
+     * Horizontal UV coordinate [0, 1] on the foliage card where the drawn woody stem/petiole attaches to the branch.
+     * @type {number}
+     */
+    stem_anchor_u = 0.5;
+
+    /**
+     * Vertical UV coordinate [0, 1] on the foliage card where the drawn woody stem/petiole attaches to the branch.
+     * @type {number}
+     */
+    stem_anchor_v = 0.0;
+
+    /**
+     * @param {Partial<FoliageMaterialConfig>} [options]
+     * @returns {FoliageMaterialConfig}
+     */
+    static from(options = {}) {
+        const r = new FoliageMaterialConfig();
+        r.applyOverrides(options);
+        return r;
+    }
+
+    /**
+     * @param {Partial<FoliageMaterialConfig>} [overrides]
+     * @returns {this}
+     */
+    applyOverrides(overrides = {}) {
+        if (overrides === null || overrides === undefined) {
+            return this;
+        }
+        if (overrides.resolution !== undefined) this.resolution = Math.max(16, overrides.resolution | 0);
+        if (overrides.primary_color !== undefined) {
+            if (Array.isArray(overrides.primary_color)) {
+                this.primary_color.setRGB(overrides.primary_color[0], overrides.primary_color[1], overrides.primary_color[2]);
+            } else {
+                this.primary_color.copy(overrides.primary_color);
+            }
+        }
+        if (overrides.secondary_color !== undefined) {
+            if (Array.isArray(overrides.secondary_color)) {
+                this.secondary_color.setRGB(overrides.secondary_color[0], overrides.secondary_color[1], overrides.secondary_color[2]);
+            } else {
+                this.secondary_color.copy(overrides.secondary_color);
+            }
+        }
+        if (overrides.autumn_tint !== undefined) this.autumn_tint = overrides.autumn_tint;
+        if (overrides.leaf_shape !== undefined) this.leaf_shape = overrides.leaf_shape;
+        if (overrides.leaflets_per_cluster !== undefined) this.leaflets_per_cluster = Math.max(1, overrides.leaflets_per_cluster | 0);
+        if (overrides.roughness !== undefined) this.roughness = overrides.roughness;
+        if (overrides.vein_strength !== undefined) this.vein_strength = overrides.vein_strength;
+        if (overrides.stem_anchor_u !== undefined) this.stem_anchor_u = overrides.stem_anchor_u;
+        if (overrides.stem_anchor_v !== undefined) this.stem_anchor_v = overrides.stem_anchor_v;
+        return this;
+    }
+
+    /**
+     * @param {FoliageMaterialConfig} other
+     * @returns {this}
+     */
+    copy(other) {
+        assert.defined(other, 'other');
+        this.resolution = other.resolution;
+        this.primary_color.copy(other.primary_color);
+        this.secondary_color.copy(other.secondary_color);
+        this.autumn_tint = other.autumn_tint;
+        this.leaf_shape = other.leaf_shape;
+        this.leaflets_per_cluster = other.leaflets_per_cluster;
+        this.roughness = other.roughness;
+        this.vein_strength = other.vein_strength;
+        this.stem_anchor_u = other.stem_anchor_u;
+        this.stem_anchor_v = other.stem_anchor_v;
+        return this;
+    }
+
+    /**
+     * @returns {FoliageMaterialConfig}
+     */
+    clone() {
+        const r = new FoliageMaterialConfig();
+        r.copy(this);
+        return r;
+    }
+
+    /**
+     * @param {FoliageMaterialConfig} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        if (this === other) return true;
+        if (!other || !other.isFoliageMaterialConfig) return false;
+        return this.resolution === other.resolution
+            && this.primary_color.equals(other.primary_color)
+            && this.secondary_color.equals(other.secondary_color)
+            && this.autumn_tint === other.autumn_tint
+            && this.leaf_shape === other.leaf_shape
+            && this.leaflets_per_cluster === other.leaflets_per_cluster
+            && this.roughness === other.roughness
+            && this.vein_strength === other.vein_strength
+            && this.stem_anchor_u === other.stem_anchor_u
+            && this.stem_anchor_v === other.stem_anchor_v;
+    }
+
+    /**
+     * @returns {number}
+     */
+    hash() {
+        let h = hash_mix2(this.resolution, this.primary_color.hash());
+        h = hash_mix2(h, this.secondary_color.hash());
+        h = hash_mix2(h, computeHashFloat(this.autumn_tint));
+        h = hash_mix2(h, computeStringHash(this.leaf_shape));
+        h = hash_mix2(h, this.leaflets_per_cluster);
+        h = hash_mix2(h, computeHashFloat(this.roughness));
+        h = hash_mix2(h, computeHashFloat(this.stem_anchor_u));
+        h = hash_mix2(h, computeHashFloat(this.stem_anchor_v));
+        return h;
+    }
+}
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+FoliageMaterialConfig.prototype.isFoliageMaterialConfig = true;

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

@@ -0,0 +1,13 @@
+/**
+ * Botanical phyllotaxis arrangement modes for axillary buds, lateral branches, and leaf clusters.
+ */
+export type PhyllotaxisMode = number;
+export namespace PhyllotaxisMode {
+    let SpiralGolden: number;
+    let AlternateDistichous: number;
+    let Tristichous: number;
+    let Opposite: number;
+    let OppositeDecussate: number;
+    let Whorled: number;
+}
+//# sourceMappingURL=PhyllotaxisMode.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"PhyllotaxisMode.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/config/PhyllotaxisMode.js"],"names":[],"mappings":";;;8BAIU,MAAM"}

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

@@ -0,0 +1,20 @@
+/**
+ * Botanical phyllotaxis arrangement modes for axillary buds, lateral branches, and leaf clusters.
+ *
+ * @readonly
+ * @enum {number}
+ */
+export const PhyllotaxisMode = {
+    /** Fibonacci golden angle (~137.507764 degrees), 1 organ per node */
+    SpiralGolden: 0,
+    /** Alternate 2-ranked (180 degrees), 1 organ per node */
+    AlternateDistichous: 1,
+    /** 3-ranked (120 degrees), 1 organ per node */
+    Tristichous: 2,
+    /** Superposed opposite pairs (0, 180 degrees), 2 organs per node */
+    Opposite: 3,
+    /** Alternating opposite pairs (rotates 90 degrees each node), 2 organs per node */
+    OppositeDecussate: 4,
+    /** M-verticillate ring around node with half-step alternation, M >= 3 organs per node */
+    Whorled: 5,
+};

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

@@ -0,0 +1,87 @@
+/**
+ * Level-of-Detail (LOD) decimation and area-compensation configuration.
+ */
+export class TreeLODConfig {
+    /**
+     * @param {Partial<TreeLODConfig>} [options]
+     * @returns {TreeLODConfig}
+     */
+    static from(options?: Partial<TreeLODConfig>): TreeLODConfig;
+    /**
+     * Creates a default sequence of progressive LOD configurations.
+     * @param {number} [lod_count=3]
+     * @returns {TreeLODConfig[]}
+     */
+    static createDefaultChain(lod_count?: number): TreeLODConfig[];
+    /**
+     * LOD index (0 = highest detail).
+     * @type {number}
+     */
+    level: number;
+    /**
+     * Multiplier in (0, 1] applied to radial ring segment counts (clamped >= 3).
+     * @type {number}
+     */
+    radial_scale: number;
+    /**
+     * Multiplier in (0, 1] applied to longitudinal Hermite spine subdivisions (clamped >= 1).
+     * @type {number}
+     */
+    longitudinal_scale: number;
+    /**
+     * Maximum branch recursion level retained in this LOD.
+     * @type {number}
+     */
+    max_branch_level: number;
+    /**
+     * Minimum branch base radius (meters) retained in this LOD.
+     * @type {number}
+     */
+    min_branch_radius: number;
+    /**
+     * Fraction in [0, 1] of foliage attachments retained via golden-ratio low-discrepancy rank.
+     * @type {number}
+     */
+    foliage_keep_ratio: number;
+    /**
+     * Area-compensation exponent eta in [0, 0.5]: remaining cards scale by `keep_ratio^(-eta)`
+     * so optical canopy density stays invariant across LOD transitions.
+     * @type {number}
+     */
+    foliage_area_compensation_exponent: number;
+    /**
+     * If true, complex cards (`TriStarCluster`, `RibbedFrond`, `OctagonalCutoutHull`) collapse
+     * to simpler low-triangle `FoldedVCard` or single quad representations.
+     * @type {boolean}
+     */
+    simplify_cards: boolean;
+    /**
+     * @param {Partial<TreeLODConfig>} [overrides]
+     * @returns {this}
+     */
+    applyOverrides(overrides?: Partial<TreeLODConfig>): this;
+    /**
+     * @param {TreeLODConfig} other
+     * @returns {this}
+     */
+    copy(other: TreeLODConfig): this;
+    /**
+     * @returns {TreeLODConfig}
+     */
+    clone(): TreeLODConfig;
+    /**
+     * @param {TreeLODConfig} other
+     * @returns {boolean}
+     */
+    equals(other: TreeLODConfig): boolean;
+    /**
+     * @returns {number}
+     */
+    hash(): number;
+    /**
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isTreeLODConfig: boolean;
+}
+//# sourceMappingURL=TreeLODConfig.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TreeLODConfig.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/config/TreeLODConfig.js"],"names":[],"mappings":"AAIA;;GAEG;AACH;IAmDI;;;OAGG;IACH,sBAHW,QAAQ,aAAa,CAAC,GACpB,aAAa,CAMzB;IAED;;;;OAIG;IACH,sCAHW,MAAM,GACJ,aAAa,EAAE,CAuD3B;IAtHD;;;OAGG;IACH,OAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,cAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,oBAFU,MAAM,CAES;IAEzB;;;OAGG;IACH,kBAFU,MAAM,CAEK;IAErB;;;OAGG;IACH,mBAFU,MAAM,CAEQ;IAExB;;;OAGG;IACH,oBAFU,MAAM,CAES;IAEzB;;;;OAIG;IACH,oCAFU,MAAM,CAE0B;IAE1C;;;;OAIG;IACH,gBAFU,OAAO,CAEM;IAwEvB;;;OAGG;IACH,2BAHW,QAAQ,aAAa,CAAC,GACpB,IAAI,CAiBhB;IAED;;;OAGG;IACH,YAHW,aAAa,GACX,IAAI,CAahB;IAED;;OAEG;IACH,SAFa,aAAa,CAMzB;IAED;;;OAGG;IACH,cAHW,aAAa,GACX,OAAO,CAanB;IAED;;OAEG;IACH,QAFa,MAAM,CAUlB;IAGL;;;OAGG;IACH,0BAFU,OAAO,CAEsB;CANtC"}

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

@@ -0,0 +1,211 @@
+import { assert } from "../../../core/assert.js";
+import { hash_mix2 } from "../../../core/math/hash/hash_mix2.js";
+import { computeHashFloat } from "../../../core/primitives/numbers/computeHashFloat.js";
+
+/**
+ * Level-of-Detail (LOD) decimation and area-compensation configuration.
+ */
+export class TreeLODConfig {
+    /**
+     * LOD index (0 = highest detail).
+     * @type {number}
+     */
+    level = 0;
+
+    /**
+     * Multiplier in (0, 1] applied to radial ring segment counts (clamped >= 3).
+     * @type {number}
+     */
+    radial_scale = 1.0;
+
+    /**
+     * Multiplier in (0, 1] applied to longitudinal Hermite spine subdivisions (clamped >= 1).
+     * @type {number}
+     */
+    longitudinal_scale = 1.0;
+
+    /**
+     * Maximum branch recursion level retained in this LOD.
+     * @type {number}
+     */
+    max_branch_level = 3;
+
+    /**
+     * Minimum branch base radius (meters) retained in this LOD.
+     * @type {number}
+     */
+    min_branch_radius = 0.0;
+
+    /**
+     * Fraction in [0, 1] of foliage attachments retained via golden-ratio low-discrepancy rank.
+     * @type {number}
+     */
+    foliage_keep_ratio = 1.0;
+
+    /**
+     * Area-compensation exponent eta in [0, 0.5]: remaining cards scale by `keep_ratio^(-eta)`
+     * so optical canopy density stays invariant across LOD transitions.
+     * @type {number}
+     */
+    foliage_area_compensation_exponent = 0.42;
+
+    /**
+     * If true, complex cards (`TriStarCluster`, `RibbedFrond`, `OctagonalCutoutHull`) collapse
+     * to simpler low-triangle `FoldedVCard` or single quad representations.
+     * @type {boolean}
+     */
+    simplify_cards = false;
+
+    /**
+     * @param {Partial<TreeLODConfig>} [options]
+     * @returns {TreeLODConfig}
+     */
+    static from(options = {}) {
+        const r = new TreeLODConfig();
+        r.applyOverrides(options);
+        return r;
+    }
+
+    /**
+     * Creates a default sequence of progressive LOD configurations.
+     * @param {number} [lod_count=3]
+     * @returns {TreeLODConfig[]}
+     */
+    static createDefaultChain(lod_count = 3) {
+        const count = Math.max(1, lod_count | 0);
+        const presets = [
+            {
+                level: 0,
+                radial_scale: 1.0,
+                longitudinal_scale: 1.0,
+                max_branch_level: 3,
+                min_branch_radius: 0.0,
+                foliage_keep_ratio: 1.0,
+                foliage_area_compensation_exponent: 0.42,
+                simplify_cards: false
+            },
+            {
+                level: 1,
+                radial_scale: 0.65,
+                longitudinal_scale: 0.7,
+                max_branch_level: 2,
+                min_branch_radius: 0.015,
+                foliage_keep_ratio: 0.55,
+                foliage_area_compensation_exponent: 0.42,
+                simplify_cards: false
+            },
+            {
+                level: 2,
+                radial_scale: 0.45,
+                longitudinal_scale: 0.5,
+                max_branch_level: 1,
+                min_branch_radius: 0.035,
+                foliage_keep_ratio: 0.28,
+                foliage_area_compensation_exponent: 0.44,
+                simplify_cards: true
+            },
+            {
+                level: 3,
+                radial_scale: 0.35,
+                longitudinal_scale: 0.35,
+                max_branch_level: 1,
+                min_branch_radius: 0.06,
+                foliage_keep_ratio: 0.15,
+                foliage_area_compensation_exponent: 0.46,
+                simplify_cards: true
+            }
+        ];
+
+        const result = [];
+        for (let i = 0; i < count; i++) {
+            const template = presets[Math.min(i, presets.length - 1)];
+            const cfg = TreeLODConfig.from(template);
+            cfg.level = i;
+            result.push(cfg);
+        }
+        return result;
+    }
+
+    /**
+     * @param {Partial<TreeLODConfig>} [overrides]
+     * @returns {this}
+     */
+    applyOverrides(overrides = {}) {
+        if (overrides === null || overrides === undefined) {
+            return this;
+        }
+        if (overrides.level !== undefined) this.level = overrides.level | 0;
+        if (overrides.radial_scale !== undefined) this.radial_scale = overrides.radial_scale;
+        if (overrides.longitudinal_scale !== undefined) this.longitudinal_scale = overrides.longitudinal_scale;
+        if (overrides.max_branch_level !== undefined) this.max_branch_level = overrides.max_branch_level | 0;
+        if (overrides.min_branch_radius !== undefined) this.min_branch_radius = overrides.min_branch_radius;
+        if (overrides.foliage_keep_ratio !== undefined) this.foliage_keep_ratio = overrides.foliage_keep_ratio;
+        if (overrides.foliage_area_compensation_exponent !== undefined) {
+            this.foliage_area_compensation_exponent = overrides.foliage_area_compensation_exponent;
+        }
+        if (overrides.simplify_cards !== undefined) this.simplify_cards = Boolean(overrides.simplify_cards);
+        return this;
+    }
+
+    /**
+     * @param {TreeLODConfig} other
+     * @returns {this}
+     */
+    copy(other) {
+        assert.defined(other, 'other');
+        this.level = other.level;
+        this.radial_scale = other.radial_scale;
+        this.longitudinal_scale = other.longitudinal_scale;
+        this.max_branch_level = other.max_branch_level;
+        this.min_branch_radius = other.min_branch_radius;
+        this.foliage_keep_ratio = other.foliage_keep_ratio;
+        this.foliage_area_compensation_exponent = other.foliage_area_compensation_exponent;
+        this.simplify_cards = other.simplify_cards;
+        return this;
+    }
+
+    /**
+     * @returns {TreeLODConfig}
+     */
+    clone() {
+        const r = new TreeLODConfig();
+        r.copy(this);
+        return r;
+    }
+
+    /**
+     * @param {TreeLODConfig} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        if (this === other) return true;
+        if (!other || !other.isTreeLODConfig) return false;
+        return this.level === other.level
+            && this.radial_scale === other.radial_scale
+            && this.longitudinal_scale === other.longitudinal_scale
+            && this.max_branch_level === other.max_branch_level
+            && this.min_branch_radius === other.min_branch_radius
+            && this.foliage_keep_ratio === other.foliage_keep_ratio
+            && this.foliage_area_compensation_exponent === other.foliage_area_compensation_exponent
+            && this.simplify_cards === other.simplify_cards;
+    }
+
+    /**
+     * @returns {number}
+     */
+    hash() {
+        let h = hash_mix2(this.level, this.max_branch_level);
+        h = hash_mix2(h, computeHashFloat(this.radial_scale));
+        h = hash_mix2(h, computeHashFloat(this.longitudinal_scale));
+        h = hash_mix2(h, computeHashFloat(this.min_branch_radius));
+        h = hash_mix2(h, computeHashFloat(this.foliage_keep_ratio));
+        h = hash_mix2(h, this.simplify_cards ? 1 : 0);
+        return h;
+    }
+}
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+TreeLODConfig.prototype.isTreeLODConfig = true;

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

@@ -0,0 +1,16 @@
+/**
+ * Built-in turn-key tree & foliage species presets.
+ */
+export type TreePreset = string;
+export namespace TreePreset {
+    let Oak: string;
+    let Pine: string;
+    let Birch: string;
+    let Willow: string;
+    let Maple: string;
+    let Spruce: string;
+    let Palm: string;
+    let Shrub: string;
+    let Fern: string;
+}
+//# sourceMappingURL=TreePreset.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TreePreset.d.ts","sourceRoot":"","sources":["../../../../../src/generation/foliage/config/TreePreset.js"],"names":[],"mappings":";;;yBAIU,MAAM"}

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

@@ -0,0 +1,17 @@
+/**
+ * Built-in turn-key tree & foliage species presets.
+ *
+ * @readonly
+ * @enum {string}
+ */
+export const TreePreset = {
+    Oak: "oak",
+    Pine: "pine",
+    Birch: "birch",
+    Willow: "willow",
+    Maple: "maple",
+    Spruce: "spruce",
+    Palm: "palm",
+    Shrub: "shrub",
+    Fern: "fern",
+};