@3driseai/3drise-viewer 0.1.41 → 0.1.43

package/dist/components/vegetation/vegetationCore.js

@@ -0,0 +1,1728 @@
+// Emitted from Claude outputs/vegetation-lab/common.mjs by gen_family.mjs — edit the lab module and re-emit.
+// Shared core of the vegetation objects (lab). Inlined verbatim into every generated component.
+//
+// A vegetation object is a solid plant standing in the scene, not a medium: it is lit by the scene's
+// lights and casts and receives shadows like a mesh. Every material is therefore a three.js lit
+// material (MeshStandardMaterial) with the plant's own code injected through onBeforeCompile:
+//   vertex    hierarchical wind (plant bend ∝ height², branch sway at the branch's own phase, leaf
+//             flutter), instanced leaf cards; the same code runs in the custom
+//             depth material so shadows move with the wind and are cut by the leaf mask.
+//   fragment  procedural bark (ridges as a bump), leaf shapes as anti-aliased SDF masks, colour from
+//             quantities (per-leaf hash, canopy depth, season), translucent back-lighting.
+//
+// Size contract: a plant is built in the unit box (x/z in [-0.5, 0.5], y in [0, 1], the ground at
+// y = 0) and the transform scale sizes it (a tree with scale [8, 12, 8] is 8 m wide and 12 m tall).
+// Knobs describe the plant, never the box.
+import * as THREE from 'three';
+export const DEG_V = Math.PI / 180;
+export const WIND_MS_VEG = 8; // m/s per unit of windStrength (same range as the environment family)
+export function mulberry32(a) {
+    return function () {
+        a |= 0;
+        a = (a + 0x6d2b79f5) | 0;
+        let t = Math.imul(a ^ (a >>> 15), 1 | a);
+        t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
+export function setColor(uniform, v) {
+    if (v === undefined || v === null)
+        return;
+    if (v.isColor)
+        uniform.value.copy(v);
+    else
+        uniform.value.set(v);
+}
+// ---------------------------------------------------------------------------- uniforms / config
+/** Uniforms every vegetation object has (shared by all of its materials). */
+export function createCommonUniforms() {
+    return {
+        uTime: { value: 0 },
+        uWindPhase: { value: 0 }, // integrated wind distance (gust fronts travel with it)
+        uWindDir: { value: new THREE.Vector2(0, 1) },
+        uWindStrength: { value: 0.2 },
+        uTurb: { value: 0.3 },
+        uSpeed: { value: 1 },
+        uSway: { value: 1 },
+        uFlutter: { value: 0.5 },
+        uScale: { value: new THREE.Vector3(1, 1, 1) }, // the transform scale (metres per unit)
+        uMean: { value: 1 }, // its geometric mean: local shapes are sized by it
+        uOpacity: { value: 1 },
+        uColor: { value: new THREE.Color('#4f8a3a') },
+        uShadeColor: { value: new THREE.Color('#1f3d1a') },
+        uSeason: { value: 0 },
+        uFoliage: { value: 1 },
+        uLeafType: { value: 0 },
+        uLeafSize: { value: 1 },
+        uGrowth: { value: 1 }, // plants scale up from their roots (crops, ivy, flowers)
+        uSunDirView: { value: new THREE.Vector3(0, 1, 0) }, // sun direction in view space (translucency only)
+        // detail levels (see "detail levels" below): the main camera, as every draw of the plant sees it
+        uViewPos: { value: new THREE.Vector3(0, 0, 1e5) }, // camera position, world
+        uLodK: { value: 1 }, // 1 / tan(fov / 2) · zoom (perspective) or 1 / half-height (orthographic)
+        uLodOrtho: { value: 0 },
+        uLodBias: { value: 1 }, // the lod knob: auto 1, full 1e6, impostor 1e-6
+        uImpReady: { value: 0 }, // the impostor atlas is baked: the far cross-fade may start
+        uBake: { value: 0 }, // 1 albedo pass, 2 normal pass (impostor bake), 0 normal render
+        uBakeView: { value: new THREE.Matrix3() }, // bake camera: view space → plant space (normal pass)
+        uBakeDepth: { value: new THREE.Vector2(1, 1) }, // bake view: camera distance to the centre, half-depth of the box along the view
+    };
+}
+/** The base knobs every vegetation object shares (push point, part 1). */
+export function applyCommonConfig(u, c) {
+    if (c.speed !== undefined)
+        u.uSpeed.value = c.speed;
+    if (c.opacity !== undefined)
+        u.uOpacity.value = c.opacity;
+    setColor(u.uColor, c.color);
+    setColor(u.uShadeColor, c.shadeColor);
+    if (c.windStrength !== undefined)
+        u.uWindStrength.value = c.windStrength;
+    if (c.windDirection !== undefined)
+        u.uWindDir.value.set(Math.sin(c.windDirection * DEG_V), Math.cos(c.windDirection * DEG_V));
+    if (c.turbulence !== undefined)
+        u.uTurb.value = c.turbulence;
+    if (c.sway !== undefined)
+        u.uSway.value = c.sway;
+    if (c.flutter !== undefined)
+        u.uFlutter.value = c.flutter;
+    if (c.seasonHue !== undefined)
+        u.uSeason.value = c.seasonHue;
+    if (c.foliage !== undefined)
+        u.uFoliage.value = c.foliage;
+    if (c.leafSize !== undefined)
+        u.uLeafSize.value = c.leafSize;
+    if (c.growth !== undefined)
+        u.uGrowth.value = c.growth;
+    if (c.leafType !== undefined)
+        u.uLeafType.value = Math.max(0, LEAF_TYPES.indexOf(c.leafType));
+}
+export const _vs = new THREE.Vector3(), _vq = new THREE.Quaternion(), _vsun = new THREE.Vector3(), _vm = new THREE.Matrix3();
+/** Per-frame bookkeeping shared by every object: scale, integrated phases, sun into view space. */
+export function updateCommon(u, object, camera, dt, sunWorld) {
+    camera.updateMatrixWorld();
+    object.updateWorldMatrix(true, false);
+    object.getWorldScale(_vs);
+    u.uScale.value.set(Math.max(_vs.x, 1e-3), Math.max(_vs.y, 1e-3), Math.max(_vs.z, 1e-3));
+    u.uMean.value = Math.cbrt(u.uScale.value.x * u.uScale.value.y * u.uScale.value.z);
+    const sp = u.uSpeed.value;
+    u.uTime.value += dt * sp;
+    u.uWindPhase.value += dt * sp * (0.4 + u.uWindStrength.value * WIND_MS_VEG);
+    camera.getWorldPosition(u.uViewPos.value);
+    if (camera.isPerspectiveCamera) {
+        u.uLodK.value = (camera.zoom || 1) / Math.tan(camera.fov * DEG_V * 0.5);
+        u.uLodOrtho.value = 0;
+    }
+    else if (camera.isOrthographicCamera) {
+        u.uLodK.value = 2 * (camera.zoom || 1) / Math.max(camera.top - camera.bottom, 1e-6);
+        u.uLodOrtho.value = 1;
+    }
+    if (sunWorld) {
+        _vm.setFromMatrix4(camera.matrixWorldInverse);
+        u.uSunDirView.value.copy(_vsun.copy(sunWorld).normalize()).applyMatrix3(_vm).normalize();
+    }
+}
+// ---------------------------------------------------------------------------- GLSL: shared pieces
+export const LEAF_TYPES = ['broadleaf', 'lobed', 'needles', 'round', 'lanceolate', 'frond', 'heart', 'petal', 'blade', 'maple'];
+export const VEG_UNIFORMS_GLSL = /* glsl */ `
+uniform float uTime, uWindPhase, uWindStrength, uTurb, uSpeed, uSway, uFlutter, uOpacity, uSeason, uFoliage, uLeafType, uLeafSize, uGrowth;
+uniform float uMean;
+uniform vec2 uWindDir;
+uniform vec3 uScale, uColor, uShadeColor, uSunDirView;
+uniform vec3 uViewPos; uniform float uLodK, uLodOrtho, uLodBias, uImpReady, uBake; uniform mat3 uBakeView; uniform vec2 uBakeDepth;
+// The plant's skeleton follows the (possibly non-uniform) transform scale; its local shapes (cards,
+// fruit, blade widths, bark rings) must not: an offset in "mean-scale units" is divided back per axis
+// so it stays isotropic in the world, and its normal is pre-multiplied by the scale so the normal
+// matrix (which undoes the scale) lands on the isotropic normal.
+vec3 isoOff(vec3 o) { return o * uMean / uScale; }
+vec3 isoNrm(vec3 n) { return normalize(n * uScale); }
+`;
+export const NOISE_GLSL_V = /* glsl */ `
+float vhash12(vec2 p) { vec3 q = fract(vec3(p.xyx) * 0.1031); q += dot(q, q.yzx + 33.33); return fract((q.x + q.y) * q.z); }
+float vhash11(float p) { p = fract(p * 0.1031); p *= p + 33.33; p *= p + p; return fract(p); }
+float vnoise2v(vec2 p) {
+    vec2 i = floor(p); vec2 f = fract(p); f = f * f * (3.0 - 2.0 * f);
+    return mix(mix(vhash12(i), vhash12(i + vec2(1, 0)), f.x), mix(vhash12(i + vec2(0, 1)), vhash12(i + vec2(1, 1)), f.x), f.y);
+}
+float fbm2v(vec2 p) { return (0.5 * vnoise2v(p) + 0.25 * vnoise2v(p * 2.03 + 7.1) + 0.125 * vnoise2v(p * 4.07 + 3.3)) / 0.875; }
+float vbump(float x) { float t = clamp(1.0 - x * x, 0.0, 1.0); return t * t; }
+vec3 qrot(vec4 q, vec3 v) { return v + 2.0 * cross(q.xyz, cross(q.xyz, v) + q.w * v); }
+`;
+/**
+ * The wind as one displacement field over the plant (unit space).
+ *   gust      low-frequency noise travelling downwind (uWindPhase), sharpened by turbulence into
+ *             separate gust fronts, so the whole plant leans and recovers rather than oscillating.
+ *   bend      the plant leans with the gust, ∝ height² (a cantilever), losing a little height.
+ *   sway      each branch oscillates at its own frequency and phase (w.x) with its own flexibility
+ *             (w.y), driven by the gust strength; sideways component so tips draw ellipses.
+ * w = (phase, flexibility). hf = height fraction of the attachment (0 ground, 1 top).
+ */
+export const WIND_GLSL = /* glsl */ `
+#ifndef VEG_M
+#define VEG_M modelMatrix
+#endif
+float gustAt(vec2 xz) {
+    // metres: the point inside the plant plus where the plant stands (modelMatrix), so gust fronts
+    // travel across a group of plants and copies of one plant (layouts) do not sway in lockstep
+    vec2 q = (xz * uScale.xz + VEG_M[3].xz) * 0.06 - uWindDir * uWindPhase * 0.08;
+    float g = vnoise2v(q) * 0.65 + vnoise2v(q * 3.1 + uTime * 0.15) * 0.35;
+    g = mix(g, smoothstep(0.35, 0.75, g), uTurb);
+    return 0.25 + 1.5 * g;
+}
+vec3 plantDisplace(vec3 p, float hf, vec2 w) {
+    float W = uWindStrength * gustAt(p.xz);
+    float h2 = hf * hf;
+    // cantilever lean: a quarter of the height in a full gale on a flexible plant
+    vec2 lean = uWindDir * W * 0.25 * h2 * uSway;
+    // branch sway: own frequency and phase, elliptical tip path
+    float f = 1.3 + 1.6 * w.y;
+    float s = sin(uTime * f + w.x * 6.2832) * W * w.y * 0.08 * uSway * hf;
+    float c = cos(uTime * f * 0.71 + w.x * 4.1) * W * w.y * 0.03 * uSway * hf;
+    vec3 d = vec3(lean.x, -0.35 * length(lean) * hf, lean.y);
+    d += vec3(uWindDir.x * s - uWindDir.y * c, 0.25 * abs(s), uWindDir.y * s + uWindDir.x * c);
+    return d;
+}
+`;
+/**
+ * Leaf shape as a signed distance in card space (x across, y along, base at y = -1, tip at y = 1),
+ * for every leaf type. Positive = outside. Anti-aliased by the caller with fwidth.
+ */
+export const LEAF_SDF_GLSL = /* glsl */ `
+// serrated margin: small teeth along the edge, finer toward the tip
+float teeth(float t, float k, float amp) { return amp * abs(sin(t * k * 3.1416)) * (1.0 - 0.5 * t); }
+float leafSdf(vec2 p, float type, float h) {
+    float t = (p.y + 1.0) * 0.5;          // 0 base .. 1 tip
+    // asymmetry: one half a little wider, the midrib slightly bowed
+    float asym = 1.0 + 0.1 * (h - 0.5) * sign(p.x);
+    float ax = abs(p.x - 0.06 * (h - 0.5) * sin(3.1416 * t));
+    if (type < 0.5) {            // broadleaf: ovate, pointed drip tip, fine serration
+        float w = (0.62 * pow(sin(3.1416 * clamp(t, 0.0, 1.0)), 0.7) * (1.0 - 0.25 * t) + 0.02 * (1.0 - t)) * asym;
+        w -= teeth(t, 14.0 + 6.0 * h, 0.025);
+        return max(ax - w, -p.y - 1.0);
+    } else if (type < 1.5) {     // lobed (oak): rounded lobes with deep sinuses
+        float lob = 0.5 + 0.5 * cos(3.1416 * (t * 7.0 + 0.5 + 0.4 * h));
+        lob = smoothstep(0.0, 1.0, lob);
+        float w = (0.3 + 0.36 * lob) * pow(sin(3.1416 * clamp(t, 0.02, 1.0)), 0.45) * asym;
+        return max(max(ax - w, -p.y - 1.0), p.y - 1.0);
+    } else if (type < 2.5) {     // needles: a tuft fanning from the base
+        float d = 1e3;
+        for (int i = 0; i < 7; i++) {
+            float a = (float(i) - 3.0) * 0.21 + 0.1 * (h - 0.5);
+            vec2 dir = vec2(sin(a), cos(a));
+            vec2 q = p - vec2(0.0, -1.0);
+            float s = clamp(dot(q, dir), 0.0, 1.9 - 0.15 * abs(float(i) - 3.0));
+            d = min(d, length(q - dir * s) - 0.035);
+        }
+        return d;
+    } else if (type < 3.5) {     // round (box, privet): obovate with a notch at the tip
+        float w = 0.68 * pow(sin(3.1416 * clamp(t, 0.0, 1.0)), 0.55) * (0.85 + 0.3 * t) * asym;
+        float notch = smoothstep(0.08, 0.0, ax) * smoothstep(0.9, 1.0, t) * 0.12;
+        return max(ax - w, -p.y - 1.0 + 0.0) + notch;
+    } else if (type < 4.5) {     // lanceolate (willow): long, narrow, finely toothed
+        float w = 0.2 * pow(sin(3.1416 * clamp(t, 0.0, 1.0)), 0.55) * asym - teeth(t, 22.0, 0.012);
+        return max(ax - w, -p.y - 1.0);
+    } else if (type < 5.5) {     // frond: a rachis with leaflets
+        float rachis = ax - 0.04;
+        float seg = fract(t * 9.0 + 0.5) - 0.5;
+        float leaflet = max(abs(seg) - 0.28 * (1.0 - t * 0.6), ax - 0.95 * (1.0 - t * 0.85) * smoothstep(0.0, 0.05, t));
+        return max(min(rachis, leaflet), -p.y - 1.0);
+    } else if (type < 6.5) {     // ivy: three to five lobes, cordate base
+        vec2 q = vec2(ax, p.y + 0.15);
+        float c = length(q - vec2(0.0, 0.1)) - 0.75;
+        float side = length(q - vec2(0.55, -0.25)) - 0.5;
+        float tip = max(ax * 1.6 - (1.0 - p.y) * 0.9, -p.y - 0.5);
+        float base = -(length(q - vec2(0.0, -0.95)) - 0.25);   // the notch at the stalk
+        return max(min(min(c, side), tip), base);
+    } else if (type < 7.5) {     // petal: a soft drop, widest near the tip, a wavy edge
+        float w = 0.55 * pow(sin(3.1416 * clamp(t, 0.0, 1.0)), 0.5) * (0.55 + 0.45 * t) * asym;
+        w += 0.03 * sin(t * 19.0 + h * 7.0) * t;
+        return max(ax - w, -p.y - 1.0);
+    } else if (type < 8.5) {     // blade (grass): tapering strip
+        return max(ax - 0.12 * (1.0 - t * 0.9), -p.y - 1.0);
+    }
+    // maple: palmate, five pointed lobes from the base
+    vec2 q = p - vec2(0.0, -0.75);
+    float r = length(q), a = atan(q.x, q.y);
+    float lobes = 0.55 + 0.55 * pow(abs(cos(a * 2.5)), 0.35) * (1.0 - 0.35 * abs(a) / 3.1416);
+    float lim = smoothstep(2.6, 1.9, abs(a));
+    return r - 1.55 * lobes * lim * (1.0 - 0.1 * h);
+}
+`;
+// ---------------------------------------------------------------------------- detail levels (constants + GLSL)
+/**
+ * Distance detail for a plant and every copy of it (layout mirrors, linked instances). One quantity
+ * decides, s: the plant's bounding radius over the camera's half-height at its distance (≈ the share of
+ * half the screen it fills). The CPU (per draw: onBeforeRender / onBeforeShadow, from the drawn mesh's
+ * own matrixWorld, so each mirror decides for itself) and the GPU (vertex, from modelMatrix) evaluate
+ * the same s from the same shared uniforms (uViewPos / uLodK = the main camera, set in updateCommon).
+ *   s > FULL               every leaf, curled cards, every branch level
+ *   FLAT..FULL             the leaf count falls toward MIN, the cards grow (1/√share, ≤ GROW) so the cover holds
+ *   s < FLAT               flat cards (2 triangles instead of 16), the finest branch level dropped
+ *   IMP·0.8 .. IMP·1.2     dithered cross-fade to the impostor (both drawn, complementary pixels)
+ *   s < IMP·0.8            the impostor alone: one octahedral-impostor card
+ * Shadow pass: flat cards, SHADOW × the leaves, trunk + first branch level; the impostor casts below IMP.
+ */
+export const LOD = { FULL: 0.45, FLAT: 0.25, IMP: 0.12, MIN: 0.3, SHADOW: 0.5, GROW: 1.8, FADE_IN: 1.2, FADE_OUT: 0.8 };
+export const LOD_GLSL_V = /* glsl */ `
+float vegLodS() {
+    if (uBake > 0.5) return 1e6;
+    mat4 M_ = VEG_M;
+    vec3 c = (M_ * vec4(0.0, 0.5, 0.0, 1.0)).xyz;
+    float R = 0.5 * sqrt(dot(M_[0].xyz, M_[0].xyz) + dot(M_[1].xyz, M_[1].xyz) + dot(M_[2].xyz, M_[2].xyz));
+    float d = uLodOrtho > 0.5 ? 1.0 : max(distance(c, uViewPos), 1e-3);
+    return R * uLodK / d * uLodBias;
+}
+float vegLodFrac(float s) { return mix(${LOD.MIN.toFixed(3)}, 1.0, smoothstep(${LOD.IMP.toFixed(3)}, ${LOD.FULL.toFixed(3)}, s)); }
+// 0 near .. 1 far: the share of pixels the impostor takes over in the cross-fade band
+float vegLodFade(float s) { return uImpReady * (1.0 - smoothstep(${(LOD.IMP * LOD.FADE_OUT).toFixed(4)}, ${(LOD.IMP * LOD.FADE_IN).toFixed(4)}, s)); }
+`;
+/** Interleaved gradient noise: the dither of the cross-fade (full detail keeps the pixels the impostor leaves). */
+export const LOD_GLSL_F = /* glsl */ `
+float vegIgn(vec2 p) { return fract(52.9829189 * fract(dot(p, vec2(0.06711056, 0.00583715)))); }
+`;
+/** Appended to every plant material's fragment: the impostor bake passes (albedo, then plant-space normal). */
+const BAKE_FRAG = /* glsl */ `
+    if (uBake > 0.5) {
+        vec3 bakeN = normalize(uBakeView * normal) * 0.5 + 0.5;
+        // coverage is binary per baked pixel (a leaf drew here or not): leaves smaller than a pixel would
+        // otherwise bake as faint alpha; the atlas mips average it into real coverage at distance
+        // the normal pass keeps the depth along the view in alpha (0 back .. 1 front): the impostor reprojects with it
+        float bakeD = clamp((uBakeDepth.x - vViewPosition.z) / (2.0 * uBakeDepth.y) + 0.5, 0.0, 1.0);
+        gl_FragColor = linearToOutputTexel(uBake < 1.5 ? vec4(diffuseColor.rgb, 1.0) : vec4(bakeN, 1.0));
+        if (uBake > 1.5) gl_FragColor.a = bakeD;
+    }`;
+function bakeOut(shader) { shader.fragmentShader = shader.fragmentShader.replace('#include <dithering_fragment>', '#include <dithering_fragment>' + BAKE_FRAG); }
+// ---------------------------------------------------------------------------- materials
+/**
+ * The shared vertex injection: wind applied at the attachment point, shared across the
+ * bark (attribute aWind = hf, phase, flex) and the instanced cards (aInfoB).
+ */
+const COMMON_VERT_PARS = /* glsl */ `
+// the plant's model matrix: per instance when the mesh is GPU-instanced (a forest's impostors), else the object's
+#ifdef USE_INSTANCING
+#define VEG_M (modelMatrix * instanceMatrix)
+#else
+#define VEG_M modelMatrix
+#endif
+${VEG_UNIFORMS_GLSL}
+${NOISE_GLSL_V}
+${WIND_GLSL}
+${LOD_GLSL_V}
+`;
+function injectUniforms(shader, u) { for (const k in u)
+    shader.uniforms[k] = u[k]; }
+/**
+ * Bark: a lit material whose vertices follow the wind (aWind = hf, phase, flex; aRing = angle 0..1,
+ * length along the branch in metres-at-scale-1) and whose surface is procedural bark: vertical ridges
+ * (anisotropic fbm), fissures darkening with depth, lichen specks on the shaded side, as a bump map.
+ */
+export function barkMaterial(u, opts) {
+    const o = Object.assign({ barkColor: '#5a4632', roughness: 0.95, ridges: 1, lod: false }, opts);
+    const mat = new THREE.MeshStandardMaterial({ color: 0xffffff, roughness: o.roughness, metalness: 0, envMapIntensity: 0.15 });
+    const own = { uBarkColor: { value: new THREE.Color(o.barkColor) }, uRidges: { value: o.ridges } };
+    mat.userData.uniforms = own;
+    const vert = (shader) => {
+        injectUniforms(shader, u);
+        injectUniforms(shader, own);
+        shader.vertexShader = shader.vertexShader
+            .replace('#include <common>', `#include <common>\n${COMMON_VERT_PARS}\nattribute vec3 aWind; attribute vec3 aRing; attribute vec3 aRoot; attribute vec3 aCentre; attribute float aGrow; varying vec3 vRing; varying float vHf;`)
+            .replace('#include <beginnormal_vertex>', `vec3 objectNormal = isoNrm(normal);\n#ifdef USE_TANGENT\nvec3 objectTangent = vec3(tangent.xyz);\n#endif`)
+            .replace('#include <begin_vertex>', `
+    // growth: the plant scales up from its root; a vine's part beyond the growth front collapses onto its axis
+    vec3 pg = aCentre + isoOff(position - aCentre) * step(aGrow, uGrowth);
+    pg = aRoot + (pg - aRoot) * uGrowth;
+    vec3 transformed = pg + plantDisplace(pg, aWind.x, aWind.yz) * uGrowth;
+    vRing = aRing; vHf = aWind.x;${o.lod ? '\n    vLodFade = vegLodFade(vegLodS());' : ''}`);
+        if (o.lod)
+            shader.vertexShader = shader.vertexShader.replace('varying float vHf;', 'varying float vHf; varying float vLodFade;');
+    };
+    mat.onBeforeCompile = (shader) => {
+        vert(shader);
+        shader.fragmentShader = shader.fragmentShader
+            .replace('#include <common>', `#include <common>\n${VEG_UNIFORMS_GLSL}\n${NOISE_GLSL_V}\nuniform vec3 uBarkColor; uniform float uRidges; varying vec3 vRing; varying float vHf;${o.lod ? ' varying float vLodFade;' : ''}
+${LOD_GLSL_F}
+float barkH(vec2 q) {
+    // plates between a network of vertical fissures (ridged noise stretched along the branch), cut by
+    // slower horizontal cracks, with fine grain on the plates
+    // two ridged layers (coarse furrows, fine furrows between them), wandering along the branch
+    float w = (vnoise2v(vec2(q.x * 2.0, q.y * 0.4) + 9.0) - 0.5) * 0.15;
+    float f1 = 1.0 - abs(2.0 * fbm2v(vec2(q.x * 12.0 + w, q.y * 1.4)) - 1.0);
+    float f2 = 1.0 - abs(2.0 * fbm2v(vec2(q.x * 30.0 - w, q.y * 4.0) + 3.0) - 1.0);
+    float fiss = pow(f1, 4.0) * 0.8 + pow(f2, 3.0) * 0.45;
+    float cracks = smoothstep(0.62, 0.78, vnoise2v(vec2(q.x * 3.0, q.y * 9.0) + 5.0));
+    float plates = vnoise2v(vec2(q.x * 7.0, q.y * 2.5) + 2.0);
+    float grain = vnoise2v(vec2(q.x * 120.0, q.y * 24.0)) * 0.1;
+    return clamp(1.0 - fiss - cracks * 0.3 + plates * 0.25 + grain - 0.05, 0.0, 1.0);
+}`)
+            .replace('#include <map_fragment>', `${o.lod ? '\n    if (vLodFade > 0.0 && vegIgn(gl_FragCoord.xy) < vLodFade) discard;' : ''}
+    float vegRough = 0.9;
+    // bark coordinates in metres: arc length around the branch, length along it
+    vec2 q = vec2(vRing.x * 6.2832 * vRing.z * uMean, vRing.y * uScale.y);
+    float hgt = barkH(q);
+    // three tones: dark fissure floor, mid plate, pale weathered plate tops
+    vec3 bark = mix(uBarkColor * 0.4, uBarkColor * 1.1, smoothstep(0.1, 0.5, hgt));
+    bark = mix(bark, uBarkColor * vec3(1.35, 1.3, 1.25), smoothstep(0.75, 1.0, hgt) * 0.6);
+    bark *= 0.9 + 0.2 * vnoise2v(q * vec2(1.5, 0.3) + 7.0);
+    // moss and lichen: low on the trunk and in the fissures, mostly on the shaded side
+    float shade = 0.5 - 0.5 * dot(normalize(vNormal), normalize(uSunDirView));
+    float moss = smoothstep(0.6, 0.8, fbm2v(q * vec2(4.0, 1.5) + 11.0) + 0.2 * (1.0 - hgt)) * smoothstep(0.5, 0.0, vHf) * (0.2 + 0.8 * shade);
+    bark = mix(bark, vec3(0.36, 0.48, 0.2), moss * 0.6);
+    float lichen = smoothstep(0.74, 0.82, vnoise2v(q * vec2(20.0, 8.0) + 3.0)) * smoothstep(0.4, 0.8, hgt) * 0.35;
+    bark = mix(bark, vec3(0.62, 0.66, 0.5), lichen);
+    diffuseColor.rgb *= bark;
+    vegRough = mix(1.0, 0.88, hgt);`)
+            .replace('#include <roughnessmap_fragment>', '#include <roughnessmap_fragment>\n    roughnessFactor = vegRough;')
+            .replace('#include <normal_fragment_maps>', `
+    {
+        // the ridge height as a bump (screen-space derivatives: no tangent frame needed)
+        vec2 q = vec2(vRing.x * 6.2832 * vRing.z * uMean, vRing.y * uScale.y);
+        float hgt = barkH(q) * 0.02 * uRidges * min(1.0, vRing.z * uMean * 8.0);
+        vec3 dpdx = dFdx(-vViewPosition), dpdy = dFdy(-vViewPosition);
+        float dhx = dFdx(hgt), dhy = dFdy(hgt);
+        vec3 r1 = cross(dpdy, normal), r2 = cross(normal, dpdx);
+        float det = dot(dpdx, r1);
+        vec3 grad = (r1 * dhx + r2 * dhy) / max(abs(det), 1e-6) * sign(det);
+        normal = normalize(normal - grad);
+    }`);
+        bakeOut(shader);
+    };
+    mat.customProgramCacheKey = () => 'veg-bark' + (o.lod ? '-lod' : '');
+    const depth = new THREE.MeshDepthMaterial({ depthPacking: THREE.RGBADepthPacking });
+    depth.onBeforeCompile = vert;
+    depth.customProgramCacheKey = () => 'veg-bark-depth' + (o.lod ? '-lod' : '');
+    return { material: mat, depth };
+}
+/**
+ * Leaf cards: one instanced draw. Per instance: aPos (attachment, unit space), aQuat (card frame:
+ * card x across, y along, z = normal), aInfoA = (size, hash, hf, ao), aInfoB = (phase, flex, order, kind).
+ * The card is a 2×2 quad; `uFoliage` keeps the leaves whose `order` is below it (the inner,
+ * late-season leaves go first). The fragment cuts the leaf shape (SDF, anti-aliased), colours from
+ * the hash, the canopy depth and the season, and adds translucent back-light.
+ */
+export function leafMaterial(u, opts) {
+    const o = Object.assign({ roughness: 0.6, translucency: 0.55, veins: 0.5, autumnA: '#e2a21c', autumnB: '#b8441c', bloom: false, underside: 0.45, lod: false }, opts);
+    const mat = new THREE.MeshStandardMaterial({ color: 0xffffff, roughness: o.roughness, metalness: 0, side: THREE.DoubleSide, alphaToCoverage: true, envMapIntensity: 0.4 });
+    const own = { uTranslucency: { value: o.translucency }, uVeins: { value: o.veins }, uAutumnA: { value: new THREE.Color(o.autumnA) }, uAutumnB: { value: new THREE.Color(o.autumnB) }, uBloom: { value: 1 }, uUnderside: { value: o.underside } };
+    mat.userData.uniforms = own;
+    const PARS = `#include <common>\n${COMMON_VERT_PARS}
+uniform float uBloom;
+attribute vec2 aCard; attribute vec3 aPos; attribute vec3 aRoot; attribute vec4 aQuat; attribute vec4 aInfoA; attribute vec4 aInfoB;
+varying vec2 vCard; varying vec4 vLeaf;${o.lod ? ' varying float vLodFade;' : ''}`;
+    // the card's own flutter: a rock about its base axis, faster and wider in wind and under the cursor;
+    // a petal (bloom material) also folds up toward its normal while the bud is closed
+    const PRE = `
+    float W_ = uWindStrength * gustAt(aPos.xz);
+    float flut = sin(uTime * (5.0 + 3.0 * aInfoB.z) + aInfoB.x * 17.0) * (0.08 + 0.35 * W_) * uFlutter${o.bloom ? ' + (1.0 - smoothstep(aInfoA.w - 0.3, aInfoA.w + 0.1, uBloom)) * 1.35' : ''};
+    // the card's own shape: it curls along its length (drooping tip) and across (a gutter or a dome),
+    // amounts from the leaf's hash, so no two leaves are the same flat quad
+    float hh = aInfoA.y;
+    float curlY = (vhash11(hh * 13.0 + 0.3) - 0.35) * ${o.curl === undefined ? '0.9' : o.curl.toFixed(2)};
+    float curlX = (vhash11(hh * 17.0 + 0.7) - 0.5) * ${o.curl === undefined ? '0.8' : o.curl.toFixed(2)};
+    float ty = (aCard.y + 1.0) * 0.5;
+    float zc = curlY * ty * ty + curlX * aCard.x * aCard.x;
+    vec3 lp0 = vec3(aCard.x, aCard.y, zc);
+    // analytic normal of z = f(x, y)
+    vec3 ln0 = normalize(vec3(-2.0 * curlX * aCard.x, -curlY * ty, 1.0));
+    float cf = cos(flut), sf = sin(flut);
+    vec3 lp = vec3(lp0.x, lp0.y * cf - lp0.z * sf, lp0.y * sf + lp0.z * cf);
+    vec3 ln = vec3(ln0.x, ln0.y * cf - ln0.z * sf, ln0.y * sf + ln0.z * cf);`;
+    const NRM = `
+    vec3 objectNormal = isoNrm(qrot(aQuat, ln));
+    #ifdef USE_TANGENT
+    vec3 objectTangent = vec3(tangent.xyz);
+    #endif`;
+    // detail levels: fewer leaves drawn at distance (the CPU sets the count), each grown so the cover holds
+    const lodPos = (depth) => !o.lod ? '' : `
+    float lodS_ = vegLodS();
+    sz *= min(${LOD.GROW.toFixed(2)}, inversesqrt(vegLodFrac(lodS_)${depth ? ` * ${LOD.SHADOW.toFixed(2)}` : ''}));${depth ? '' : '\n    vLodFade = vegLodFade(lodS_);'}`;
+    const POS = (depth) => `
+    // growth: the leaf's plant scales up from its root; a leaf past the growth front (aInfoB.w) is not there yet
+    float keep = step(aInfoB.z, uFoliage) * step(aInfoB.w, uGrowth);
+    vec3 ap = aRoot + (aPos - aRoot) * uGrowth;
+    float sz = aInfoA.x * uLeafSize * keep * uGrowth;${lodPos(depth)}
+    vec3 transformed = ap + isoOff(qrot(aQuat, (lp + vec3(0.0, 1.0, 0.0)) * sz)) + plantDisplace(ap, aInfoA.z, aInfoB.xy) * uGrowth;
+    vCard = aCard; vLeaf = vec4(aInfoA.y, aInfoA.w, aInfoB.w, aInfoA.z);`;
+    const vert = (shader, depth = false) => {
+        injectUniforms(shader, u);
+        injectUniforms(shader, own);
+        shader.vertexShader = depth
+            ? shader.vertexShader.replace('#include <common>', PARS).replace('#include <begin_vertex>', PRE + POS(true))
+            : shader.vertexShader.replace('#include <common>', PARS).replace('#include <beginnormal_vertex>', PRE + NRM).replace('#include <begin_vertex>', POS(false));
+    };
+    const fragMask = `
+    float lsd = leafSdf(vCard, uLeafType, vLeaf.x);
+    float aa = fwidth(lsd) * 0.9;
+    float cover = 1.0 - smoothstep(-aa, aa, lsd);
+    if (cover < 0.02) discard;
+    float vegRough = 0.5; float leafHgt = 0.0;`;
+    mat.onBeforeCompile = (shader) => {
+        vert(shader);
+        shader.fragmentShader = shader.fragmentShader
+            .replace('#include <common>', `#include <common>\n${VEG_UNIFORMS_GLSL}\n${NOISE_GLSL_V}\n${LEAF_SDF_GLSL}
+uniform float uTranslucency, uVeins, uUnderside; uniform vec3 uAutumnA, uAutumnB;
+varying vec2 vCard; varying vec4 vLeaf;${o.lod ? ' varying float vLodFade;' : ''}
+${LOD_GLSL_F}`)
+            .replace('#include <map_fragment>', `${o.lod ? '\n    if (vLodFade > 0.0 && vegIgn(gl_FragCoord.xy) < vLodFade) discard;' : ''}${fragMask}
+    float h = vLeaf.x, ao = vLeaf.y;
+    float t = (vCard.y + 1.0) * 0.5;
+    // colour from quantities: per-leaf hue/value scatter, canopy depth (inner leaves in shade), season
+    vec3 base = uColor * (0.8 + 0.4 * vhash11(h * 7.0 + 1.0));
+    base = mix(base * vec3(0.92, 1.04, 0.78), base * vec3(0.98, 1.0, 1.04), vhash11(h * 3.0 + 2.0));
+    base = mix(uShadeColor, base, 0.15 + 0.85 * ao);
+    // young leaves (tip of the canopy) a touch yellower, the blade base paler
+    base = mix(base, base * vec3(1.08, 1.04, 0.75), 0.25 * (1.0 - t) );
+    vec3 autumn = mix(uAutumnA, uAutumnB, vhash11(h * 5.0 + 3.0));
+    float turn = smoothstep(h * 0.7 + 0.05, h * 0.7 + 0.45, uSeason);
+    base = mix(base, autumn, turn);
+    // dry brown margin as the season turns
+    float edge = smoothstep(-0.08, 0.0, lsd);
+    base = mix(base, vec3(0.42, 0.26, 0.1), edge * smoothstep(0.3, 0.9, turn) * 0.8);
+    // the vein network: a tapered midrib, secondaries leaving it at an angle and curving to the margin,
+    // a fine tertiary net; veins are paler and sit in shallow grooves (height field → bump)
+    float mid = 1.0 - smoothstep(0.0, 0.035 * (1.0 - 0.6 * t), abs(vCard.x));
+    float side = abs(vCard.x);
+    float sec = fract((t - side * 0.35) * (7.0 + 2.0 * vhash11(h * 2.0)) + 0.3);
+    float secL = 1.0 - smoothstep(0.0, 0.04, abs(sec - 0.5) - 0.0);
+    secL *= smoothstep(0.0, 0.06, side) * (1.0 - 0.5 * t);
+    float tert = smoothstep(0.55, 0.75, vnoise2v(vCard * vec2(14.0, 22.0) + h * 9.0)) * 0.3;
+    float vein = max(mid, max(secL * 0.55, tert * 0.6)) * uVeins;
+    base = mix(base, base * vec3(1.18, 1.12, 0.82), vein * 0.8);
+    // the underside is paler, bluer and matte
+    if (!gl_FrontFacing) base = mix(base, vec3(dot(base, vec3(0.33))) * vec3(0.85, 0.95, 0.85) + 0.08, uUnderside);
+    diffuseColor.rgb *= base;
+    diffuseColor.a *= cover * uOpacity;
+    vegRough = gl_FrontFacing ? mix(0.42, 0.62, vhash11(h * 4.0)) + 0.25 * turn : 0.85;
+    // bump: veins recessed, cells between the secondaries bulging, the edge rolled
+    leafHgt = (-0.5 * vein + 0.25 * (1.0 - secL) * (1.0 - mid) * uVeins) * 0.0025 + 0.004 * smoothstep(-0.12, 0.0, lsd);`)
+            .replace('#include <roughnessmap_fragment>', '#include <roughnessmap_fragment>\n    roughnessFactor = vegRough;')
+            .replace('#include <normal_fragment_maps>', `#include <normal_fragment_maps>
+    {
+        vec3 dpdx = dFdx(-vViewPosition), dpdy = dFdy(-vViewPosition);
+        float dhx = dFdx(leafHgt), dhy = dFdy(leafHgt);
+        vec3 r1 = cross(dpdy, normal), r2 = cross(normal, dpdx);
+        float det = dot(dpdx, r1);
+        vec3 grad = (r1 * dhx + r2 * dhy) / max(abs(det), 1e-7) * sign(det);
+        normal = normalize(normal - grad);
+    }`)
+            .replace('#include <lights_fragment_end>', `#include <lights_fragment_end>
+    {
+        // translucency: sun through the blade when it is behind the leaf; veins and the midrib are thicker
+        float back = max(dot(-normal, uSunDirView), 0.0);
+        float thin = 1.0 - 0.6 * max(mid, secL * 0.7);
+        reflectedLight.indirectDiffuse += diffuseColor.rgb * vec3(1.05, 1.1, 0.7) * back * uTranslucency * thin * 1.1;
+    }`);
+        bakeOut(shader);
+    };
+    // every option that changes the shader text is in the key (leaf materials with different curls must not share a program)
+    const leafKey = 'veg-leaf:' + [o.bloom ? 1 : 0, o.curl === undefined ? 'd' : o.curl.toFixed(2), o.lod ? 1 : 0].join(',');
+    mat.customProgramCacheKey = () => leafKey;
+    const depth = new THREE.MeshDepthMaterial({ depthPacking: THREE.RGBADepthPacking, side: THREE.DoubleSide });
+    depth.onBeforeCompile = (shader) => {
+        vert(shader, true);
+        shader.fragmentShader = shader.fragmentShader
+            .replace('#include <common>', `#include <common>\n${VEG_UNIFORMS_GLSL}\n${LEAF_SDF_GLSL}\nvarying vec2 vCard; varying vec4 vLeaf;`)
+            .replace('#include <map_fragment>', fragMask);
+    };
+    depth.customProgramCacheKey = () => leafKey + ':depth';
+    return { material: mat, depth };
+}
+/** The leaf card: a 3×5 grid (so it can curl along and across) with instance buffers for `count` leaves. */
+export const CARD_NX = 3, CARD_NY = 5;
+/** Index counts: the curled grid, then the flat card that follows it. */
+export const CARD_IDX = (CARD_NX - 1) * (CARD_NY - 1) * 6, FLAT_IDX = 6;
+export function leafGeometry(count) {
+    const geo = new THREE.InstancedBufferGeometry();
+    const P = [], C = [], N = [], U = [], I = [];
+    const box = [[-0.5, 0, -0.5], [0.5, 0, 0.5], [0.5, 1, -0.5], [-0.5, 1, 0.5]];
+    let k = 0;
+    for (let j = 0; j < CARD_NY; j++)
+        for (let i = 0; i < CARD_NX; i++) {
+            // `position` holds only unit-box corners (what Box3.expandByObject reads); the card is aCard
+            const bp = box[k++ % 4];
+            P.push(bp[0], bp[1], bp[2]);
+            C.push(-1 + 2 * i / (CARD_NX - 1), -1 + 2 * j / (CARD_NY - 1));
+            N.push(0, 0, 1);
+            U.push(i / (CARD_NX - 1), j / (CARD_NY - 1));
+        }
+    for (let j = 0; j < CARD_NY - 1; j++)
+        for (let i = 0; i < CARD_NX - 1; i++) {
+            const a = j * CARD_NX + i, b = a + 1, c = a + CARD_NX, d = c + 1;
+            I.push(a, b, d, a, d, c);
+        }
+    // a flat card from the grid's four corners, after the grid (detail levels draw it at distance)
+    const c0 = 0, c1 = CARD_NX - 1, c2 = (CARD_NY - 1) * CARD_NX, c3 = CARD_NY * CARD_NX - 1;
+    I.push(c0, c1, c3, c0, c3, c2);
+    geo.setAttribute('position', new THREE.Float32BufferAttribute(P, 3));
+    geo.setAttribute('aCard', new THREE.Float32BufferAttribute(C, 2));
+    geo.setAttribute('normal', new THREE.Float32BufferAttribute(N, 3));
+    geo.setAttribute('uv', new THREE.Float32BufferAttribute(U, 2));
+    geo.setIndex(I);
+    geo.setDrawRange(0, CARD_IDX);
+    geo.setAttribute('aPos', new THREE.InstancedBufferAttribute(new Float32Array(count * 3), 3));
+    geo.setAttribute('aRoot', new THREE.InstancedBufferAttribute(new Float32Array(count * 3), 3));
+    geo.setAttribute('aQuat', new THREE.InstancedBufferAttribute(new Float32Array(count * 4), 4));
+    geo.setAttribute('aInfoA', new THREE.InstancedBufferAttribute(new Float32Array(count * 4), 4));
+    geo.setAttribute('aInfoB', new THREE.InstancedBufferAttribute(new Float32Array(count * 4), 4));
+    geo.instanceCount = count;
+    return geo;
+}
+const _q = new THREE.Quaternion(), _m = new THREE.Matrix4(), _x = new THREE.Vector3(), _y = new THREE.Vector3(), _z = new THREE.Vector3();
+/** Writes leaf i: attachment, frame from (along = card +y, normal = card +z), size, hash, hf, ao, phase, flex, order, kind. */
+export function setLeaf(geo, i, pos, along, normal, size, hash, hf, ao, phase, flex, order, kind) {
+    _y.copy(along).normalize();
+    _z.copy(normal).addScaledVector(_y, -normal.dot(_y)).normalize();
+    if (_z.lengthSq() < 1e-6)
+        _z.set(0, 0, 1).addScaledVector(_y, -_y.z).normalize();
+    _x.crossVectors(_y, _z).normalize();
+    _m.makeBasis(_x, _y, _z);
+    _q.setFromRotationMatrix(_m);
+    geo.attributes.aPos.setXYZ(i, pos.x, pos.y, pos.z);
+    geo.attributes.aQuat.setXYZW(i, _q.x, _q.y, _q.z, _q.w);
+    geo.attributes.aInfoA.setXYZW(i, size, hash, hf, ao);
+    geo.attributes.aInfoB.setXYZW(i, phase, flex, order, kind || 0);
+}
+/** The leaf's plant root (for growth). */
+export function setLeafRoot(geo, i, root) { geo.attributes.aRoot.setXYZ(i, root.x, root.y, root.z); }
+/** Bounds-only: the unit box, so Box3.expandByObject centres the gizmo on the plant (instanced attrs are not read). */
+export function unitBounds(geo) {
+    geo.boundingSphere = new THREE.Sphere(new THREE.Vector3(0, 0.5, 0), 0.9);
+    geo.boundingBox = new THREE.Box3(new THREE.Vector3(-0.5, 0, -0.5), new THREE.Vector3(0.5, 1, 0.5));
+}
+// ---------------------------------------------------------------------------- branching generator
+/**
+ * A parametric branching model (after Weber & Penn): each level has a child count, length and
+ * radius ratios, a down angle from the parent, a phyllotactic rotation, curvature and gravity
+ * (droop). A branch is a polyline with tapering radii; the crown silhouette is a shape function of
+ * the attachment height. Deterministic for a seed. Lengths in unit space (height 1).
+ *
+ * params:
+ *   levels          number of branch levels after the trunk (0..3)
+ *   trunk           { length, radius, taper, curve, segments, splits? }
+ *   level[i]        { count, length, radius, downAngle, downVar, curve, curveVar, segments, start }
+ *   shape(t)        crown silhouette multiplier for first-level branch length by attachment t
+ *   droop           gravity on the branches (negative lifts them)
+ *   twist           extra random curvature
+ *   leaves          { perLength, size, sizeVar, spread, fromLevel, tuft }
+ * Returns { branches: [{ level, pts, radii, hf0, phase, flex }], leaves: [{ pos, along, normal, size, hf, ao, phase, flex, order }] }.
+ */
+export function generatePlant(P, rnd) {
+    const branches = [], leaves = [];
+    const up = new THREE.Vector3(0, 1, 0);
+    const tmpA = new THREE.Vector3(), tmpB = new THREE.Vector3(), axis = new THREE.Vector3();
+    const lv = P.level || [];
+    const levels = Math.min(P.levels, lv.length);
+    const maxBranches = P.maxBranches || 2500;
+    function perpendicular(d, out) {
+        out.crossVectors(d, Math.abs(d.y) < 0.9 ? up : tmpB.set(1, 0, 0)).normalize();
+        return out;
+    }
+    function grow(level, start, dir, length, radius, hf0, phase, flex, parentFlex) {
+        if (branches.length > maxBranches)
+            return;
+        const L = level < 0 ? P.trunk : lv[level];
+        const segs = Math.max(2, L.segments || 5);
+        const pts = [start.clone()], radii = [radius];
+        const d = dir.clone().normalize(), p = start.clone();
+        const curve = (L.curve || 0) * DEG_V * (1 + (rnd() - 0.5) * (L.curveVar || 0));
+        perpendicular(d, axis);
+        const bendAxis = axis.clone().applyAxisAngle(d, rnd() * Math.PI * 2);
+        const droop = (P.droop || 0) * (level < 0 ? 0.15 : 0.5 + 0.5 * level / Math.max(levels, 1));
+        for (let i = 1; i <= segs; i++) {
+            d.applyAxisAngle(bendAxis, curve / segs);
+            // twist: random wander, more on thin branches
+            if (P.twist) {
+                perpendicular(d, axis).applyAxisAngle(d, rnd() * Math.PI * 2);
+                d.applyAxisAngle(axis, (rnd() - 0.5) * P.twist * 0.9 / segs * (1 + level));
+            }
+            // gravity and phototropism
+            d.y -= droop * 0.9 / segs * (i / segs);
+            d.y += (P.photo || 0) * 0.3 / segs;
+            d.normalize();
+            p.addScaledVector(d, length / segs);
+            pts.push(p.clone());
+            radii.push(radius * (1 - (L.taper === undefined ? 0.85 : L.taper) * i / segs));
+        }
+        const hfEnd = Math.min(1, Math.max(0, p.y));
+        branches.push({ level, pts, radii, hf0, phase, flex, tip: d.clone() });
+        const tipFlex = flex;
+        // forks: the trunk (or a limb) splits at its end into a few continuing limbs of nearly its size
+        if (L.splits && level + 1 < levels) {
+            const nS = L.splits, az0 = rnd() * Math.PI * 2;
+            for (let k = 0; k < nS; k++) {
+                const cd = d.clone();
+                perpendicular(cd, axis).applyAxisAngle(cd, az0 + k / nS * Math.PI * 2 + (rnd() - 0.5) * 0.6);
+                cd.applyAxisAngle(axis, (L.splitAngle || 28) * DEG_V * (0.7 + 0.6 * rnd())).normalize();
+                const rEnd = radii[radii.length - 1];
+                grow(level + 1, p.clone(), cd, length * (L.splitLength || 0.9) * (0.85 + 0.3 * rnd()), Math.max(rEnd * (L.splitRadius || 0.8), 0.0015), Math.min(1, Math.max(0, p.y)), rnd(), Math.min(1, tipFlex + 0.15), tipFlex);
+            }
+        }
+        // children
+        if (level + 1 < levels) {
+            const C = lv[level + 1];
+            let n = Math.round(C.count * (P.branchiness || 1) * (0.8 + 0.4 * rnd()));
+            if (level < 0 && P.whorls)
+                n = Math.round(C.count * (P.branchiness || 1));
+            const start = C.start === undefined ? 0.3 : C.start;
+            let az = rnd() * Math.PI * 2;
+            for (let k = 0; k < n; k++) {
+                let t;
+                if (P.whorls && level < 0) {
+                    const w = Math.floor(k / P.whorls);
+                    const nw = Math.ceil(n / P.whorls);
+                    t = start + (1 - start) * (w + 0.5) / nw;
+                    az = (k % P.whorls) / P.whorls * Math.PI * 2 + w * 0.5;
+                }
+                else {
+                    t = start + (1 - start) * (k + rnd() * 0.8) / n;
+                    az += 137.5 * DEG_V + (rnd() - 0.5) * (C.azVar || 0.6);
+                }
+                const seg = Math.min(segs - 1, Math.floor(t * segs)), f = t * segs - seg;
+                tmpA.lerpVectors(pts[seg], pts[seg + 1], f);
+                const tangent = tmpB.subVectors(pts[seg + 1], pts[seg]).normalize();
+                const shape = level < 0 && P.shape ? P.shape(t) : 1;
+                const childLen = length * C.length * shape * (0.8 + 0.4 * rnd());
+                if (childLen < 0.01)
+                    continue;
+                const rAt = radii[seg] * (1 - f) + radii[seg + 1] * f;
+                const childR = Math.min(rAt * 0.9, rAt * (C.radius === undefined ? 0.7 : C.radius) * Math.pow(Math.max(shape, 0.2), 0.5));
+                const down = (C.downAngle + (rnd() - 0.5) * (C.downVar || 0)) * DEG_V;
+                const cd = tangent.clone();
+                perpendicular(cd, axis).applyAxisAngle(cd, az);
+                cd.applyAxisAngle(axis, down).normalize();
+                const cflex = Math.min(1, tipFlex + 0.25 + 0.15 * level) * (0.8 + 0.4 * rnd());
+                grow(level + 1, tmpA.clone(), cd, childLen, Math.max(childR, 0.0015), Math.min(1, Math.max(0, tmpA.y)), rnd(), cflex, tipFlex);
+            }
+        }
+        // leaves
+        const LF = P.leaves;
+        if (LF && level >= (LF.fromLevel === undefined ? levels - 1 : LF.fromLevel)) {
+            const nL = LF.perBranch ? LF.perBranch : Math.max(1, Math.round(length * LF.perLength * (LF.density || 1)));
+            const t0 = LF.start === undefined ? 0.2 : LF.start;
+            for (let k = 0; k < nL; k++) {
+                const t = t0 + (1 - t0) * (k + rnd()) / nL;
+                const seg = Math.min(segs - 1, Math.floor(t * segs)), f = t * segs - seg;
+                const pos = new THREE.Vector3().lerpVectors(pts[seg], pts[seg + 1], f);
+                const tangent = new THREE.Vector3().subVectors(pts[seg + 1], pts[seg]).normalize();
+                const tuft = LF.tuft || 1;
+                for (let j = 0; j < tuft; j++) {
+                    // along: away from the twig, tilted toward the tip and upward (phototropism), scattered
+                    const along = new THREE.Vector3().copy(perpendicular(tangent, axis)).applyAxisAngle(tangent, rnd() * Math.PI * 2);
+                    along.multiplyScalar(LF.spread === undefined ? 0.8 : LF.spread).addScaledVector(tangent, 0.45 + rnd() * 0.5).add(up.clone().multiplyScalar(LF.lift === undefined ? 0.25 : LF.lift)).normalize();
+                    // normal: mostly up/outward with scatter, so leaves face the light
+                    const normal = new THREE.Vector3(rnd() - 0.5, 1.2 * (LF.faceUp === undefined ? 1 : LF.faceUp), rnd() - 0.5).addScaledVector(along, 0.3).normalize();
+                    if (rnd() < 0.3)
+                        normal.multiplyScalar(-1);
+                    const size = LF.size * (1 + (rnd() - 0.5) * (LF.sizeVar || 0.4));
+                    const off = (rnd() - 0.5) * 0.3 * size;
+                    leaves.push({ pos: pos.clone().addScaledVector(along, off).addScaledVector(tangent, (rnd() - 0.5) * 0.02), along, normal, size, hf: Math.min(1, Math.max(0, pos.y)), ao: 0, phase: phase + rnd() * 0.2, flex: tipFlex * (0.8 + 0.4 * t), order: 0 });
+                }
+            }
+        }
+    }
+    const T = P.trunk;
+    grow(-1, new THREE.Vector3(0, 0, 0), new THREE.Vector3((rnd() - 0.5) * (T.lean || 0), 1, (rnd() - 0.5) * (T.lean || 0)).normalize(), T.length, T.radius, 0, rnd(), T.flex === undefined ? 0.1 : T.flex, 0);
+    // canopy occlusion: how many leaves sit around each leaf (a 3-D count grid) plus the depth below
+    // the canopy top — the outer, upper leaves are lit, the inner and lower ones in shade
+    if (leaves.length) {
+        const c = new THREE.Vector3();
+        let yMin = 1e9, yMax = -1e9;
+        for (const l of leaves) {
+            c.add(l.pos);
+            yMin = Math.min(yMin, l.pos.y);
+            yMax = Math.max(yMax, l.pos.y);
+        }
+        c.divideScalar(leaves.length);
+        let rMax = 1e-6;
+        for (const l of leaves)
+            rMax = Math.max(rMax, l.pos.distanceTo(c));
+        const cell = rMax / 7, grid = new Map();
+        const key = (p) => (Math.floor(p.x / cell) * 73856093) ^ (Math.floor(p.y / cell) * 19349663) ^ (Math.floor(p.z / cell) * 83492791);
+        for (const l of leaves) {
+            const k = key(l.pos);
+            grid.set(k, (grid.get(k) || 0) + 1);
+        }
+        let cMax = 1;
+        const counts = leaves.map((l) => { let n = 0; for (let dx = -1; dx <= 1; dx++)
+            for (let dy = -1; dy <= 1; dy++)
+                for (let dz = -1; dz <= 1; dz++) {
+                    const k = (Math.floor(l.pos.x / cell + dx) * 73856093) ^ (Math.floor(l.pos.y / cell + dy) * 19349663) ^ (Math.floor(l.pos.z / cell + dz) * 83492791);
+                    n += grid.get(k) || 0;
+                } if (n > cMax)
+            cMax = n; return n; });
+        leaves.forEach((l, i) => {
+            const dens = Math.min(1, counts[i] / (cMax * 0.6));
+            const up = (l.pos.y - yMin) / Math.max(yMax - yMin, 1e-6);
+            l.ao = Math.min(1, Math.max(0, 1.05 - 0.8 * dens * dens + 0.25 * up - 0.2));
+            l.order = Math.min(0.999, (1 - l.ao) * 0.6 + rnd() * 0.4);
+        });
+    }
+    return { branches, leaves };
+}
+/**
+ * Generalized cylinders for every branch, merged in one geometry: rings of `sides` vertices
+ * (fewer on thin branches) along the polyline, parallel-transport frames, a pointed cap.
+ * Attributes: position, normal, aRing (angle 0..1, length along), aWind (hf, phase, flex).
+ */
+export function branchGeometry(branches, opts) {
+    const o = Object.assign({ sides: [10, 7, 5, 4, 3], minRadius: 0.0008, flare: null }, opts);
+    const pos = [], nrm = [], ring = [], wind = [], root = [], centre = [], grow = [], idx = [];
+    const n = new THREE.Vector3(), b = new THREE.Vector3(), t = new THREE.Vector3(), prevT = new THREE.Vector3();
+    const zero = new THREE.Vector3();
+    // sorted by level (trunk first) so a prefix of the index buffer is "trunk … level k" (detail levels)
+    const sorted = branches.slice().sort((a, b) => a.level - b.level);
+    const levelEnds = [];
+    for (const br of sorted) {
+        const sides = o.sides[Math.min(o.sides.length - 1, br.level + 1)];
+        const base = pos.length / 3;
+        let along = 0;
+        // initial frame
+        t.subVectors(br.pts[1], br.pts[0]).normalize();
+        n.crossVectors(t, Math.abs(t.y) < 0.9 ? new THREE.Vector3(0, 1, 0) : new THREE.Vector3(1, 0, 0)).normalize();
+        b.crossVectors(t, n);
+        for (let i = 0; i < br.pts.length; i++) {
+            if (i > 0) {
+                prevT.copy(t);
+                if (i < br.pts.length - 1)
+                    t.subVectors(br.pts[i + 1], br.pts[i - 1]).normalize();
+                else
+                    t.subVectors(br.pts[i], br.pts[i - 1]).normalize();
+                // parallel transport: rotate the frame by the tangent change
+                const ax = new THREE.Vector3().crossVectors(prevT, t);
+                if (ax.lengthSq() > 1e-10) {
+                    const ang = Math.acos(Math.min(1, Math.max(-1, prevT.dot(t))));
+                    ax.normalize();
+                    n.applyAxisAngle(ax, ang);
+                    b.applyAxisAngle(ax, ang);
+                }
+                along += br.pts[i].distanceTo(br.pts[i - 1]);
+            }
+            const r = Math.max(br.radii[i], o.minRadius);
+            const hf = Math.min(1, Math.max(0, br.pts[i].y));
+            const flex = br.flex * Math.min(1, 0.3 + 0.7 * (i / (br.pts.length - 1)));
+            const rt = br.root || zero, gr = br.grow ? br.grow[i] : 0;
+            for (let s = 0; s <= sides; s++) {
+                const a = s / sides * Math.PI * 2, ca = Math.cos(a), sa = Math.sin(a);
+                // flare(branch, ringIndex, angle) → radius multiplier (root buttresses, a flared base)
+                const rr = o.flare ? r * o.flare(br, i, a) : r;
+                pos.push(br.pts[i].x + (n.x * ca + b.x * sa) * rr, br.pts[i].y + (n.y * ca + b.y * sa) * rr, br.pts[i].z + (n.z * ca + b.z * sa) * rr);
+                nrm.push(n.x * ca + b.x * sa, n.y * ca + b.y * sa, n.z * ca + b.z * sa);
+                ring.push(s / sides, along, br.radii[0]); // the base radius: a stable arc-length coordinate along the whole branch
+                wind.push(hf, br.phase, flex);
+                root.push(rt.x, rt.y, rt.z);
+                centre.push(br.pts[i].x, br.pts[i].y, br.pts[i].z);
+                grow.push(gr);
+            }
+        }
+        const rows = br.pts.length, cols = sides + 1;
+        for (let i = 0; i < rows - 1; i++)
+            for (let s = 0; s < sides; s++) {
+                const a = base + i * cols + s, c = a + cols;
+                idx.push(a, a + 1, c, a + 1, c + 1, c);
+            }
+        // cap
+        const tipI = pos.length / 3;
+        const tipP = br.pts[rows - 1].clone().addScaledVector(t, Math.max(br.radii[rows - 1], o.minRadius) * 1.5);
+        pos.push(tipP.x, tipP.y, tipP.z);
+        nrm.push(t.x, t.y, t.z);
+        ring.push(0.5, along, 0.001);
+        wind.push(Math.min(1, Math.max(0, tipP.y)), br.phase, br.flex);
+        {
+            const rt = br.root || zero;
+            root.push(rt.x, rt.y, rt.z);
+            centre.push(tipP.x, tipP.y, tipP.z);
+            grow.push(br.grow ? br.grow[rows - 1] : 0);
+        }
+        const last = base + (rows - 1) * cols;
+        for (let s = 0; s < sides; s++)
+            idx.push(last + s, last + s + 1, tipI);
+        levelEnds[br.level + 1] = idx.length; // the index count once this level is complete
+    }
+    const geo = new THREE.BufferGeometry();
+    geo.setAttribute('position', new THREE.Float32BufferAttribute(pos, 3));
+    geo.setAttribute('normal', new THREE.Float32BufferAttribute(nrm, 3));
+    geo.setAttribute('aRing', new THREE.Float32BufferAttribute(ring, 3));
+    geo.setAttribute('aWind', new THREE.Float32BufferAttribute(wind, 3));
+    geo.setAttribute('aRoot', new THREE.Float32BufferAttribute(root, 3));
+    geo.setAttribute('aCentre', new THREE.Float32BufferAttribute(centre, 3));
+    geo.setAttribute('aGrow', new THREE.Float32BufferAttribute(grow, 1));
+    geo.setIndex(idx);
+    // [end of trunk, end of level 0, …]: holes (a level with no branches) take the previous end
+    for (let i = 0; i < levelEnds.length; i++)
+        if (levelEnds[i] === undefined)
+            levelEnds[i] = i ? levelEnds[i - 1] : 0;
+    geo.userData.levelEnds = levelEnds;
+    return geo;
+}
+/** Fills a leaf geometry from generatePlant's leaves (optionally the first `count`). */
+export function fillLeaves(geo, leaves, kind = undefined) {
+    const n = Math.min(geo.instanceCount, leaves.length);
+    for (let i = 0; i < n; i++) {
+        const l = leaves[i];
+        setLeaf(geo, i, l.pos, l.along, l.normal, l.size, (i * 0.618033) % 1, l.hf, l.ao, l.phase, l.flex, l.order, l.grow || kind || 0);
+        if (l.root)
+            setLeafRoot(geo, i, l.root);
+    }
+    geo.instanceCount = n;
+    for (const k of ['aPos', 'aRoot', 'aQuat', 'aInfoA', 'aInfoB'])
+        geo.attributes[k].needsUpdate = true;
+    return n;
+}
+// ---------------------------------------------------------------------------- fruit on the plant
+/**
+ * Hanging fruit: instanced low-poly spheroids at a subset of the leaf positions, shaped per kind in
+ * the vertex shader (oblate / prolate / dimple / taper), skinned per kind in the fragment (two
+ * colours by ripeness, waxy specular, pores / streaks), swinging with the branch.
+ * aPos, aInfo = (size, hash, hf, order), aWind = (phase, flex).
+ */
+export const FRUIT_KINDS = ['none', 'apple', 'orange', 'lemon', 'cherry', 'pear', 'plum', 'berry', 'rosehip'];
+// shape: elongation (y stretch), dimple (top/bottom indent), taper (narrower top), size (m at scale 1 tree ~ relative), colours
+export const FRUIT_PROFILES = {
+    apple: { elong: 0.92, dimple: 0.35, taper: 0.1, size: 1.0, unripe: '#7fae3c', ripe: '#c8302a', gloss: 0.5, streaks: 0.6, pores: 0 },
+    orange: { elong: 0.95, dimple: 0.1, taper: 0.0, size: 1.0, unripe: '#7fa83a', ripe: '#ef8a1d', gloss: 0.25, streaks: 0, pores: 1 },
+    lemon: { elong: 1.35, dimple: -0.3, taper: 0.05, size: 0.85, unripe: '#8fb53c', ripe: '#f2d82a', gloss: 0.3, streaks: 0, pores: 0.8 },
+    cherry: { elong: 0.9, dimple: 0.4, taper: 0.0, size: 0.35, unripe: '#d8c060', ripe: '#8a1324', gloss: 0.9, streaks: 0, pores: 0 },
+    pear: { elong: 1.3, dimple: 0.1, taper: 0.55, size: 1.05, unripe: '#9cbd4a', ripe: '#cfc24a', gloss: 0.2, streaks: 0.3, pores: 0.3 },
+    plum: { elong: 1.05, dimple: 0.2, taper: 0.05, size: 0.65, unripe: '#8aa34a', ripe: '#4a1d4f', gloss: 0.7, streaks: 0, pores: 0 },
+    berry: { elong: 0.95, dimple: 0.3, taper: 0.0, size: 0.25, unripe: '#9fcf7a', ripe: '#3a2f6e', gloss: 0.6, streaks: 0, pores: 0 },
+    rosehip: { elong: 1.25, dimple: -0.2, taper: 0.1, size: 0.3, unripe: '#9fbf4a', ripe: '#d5361e', gloss: 0.8, streaks: 0, pores: 0 },
+};
+export function fruitMaterial(u) {
+    const mat = new THREE.MeshStandardMaterial({ color: 0xffffff, roughness: 0.45, metalness: 0 });
+    const own = {
+        uFruitShape: { value: new THREE.Vector4(1, 0, 0, 1) }, // elong, dimple, taper, size
+        uFruitSkin: { value: new THREE.Vector4(0.5, 0, 0, 0) }, // gloss, streaks, pores, -
+        uFruitUnripe: { value: new THREE.Color('#7fae3c') }, uFruitRipe: { value: new THREE.Color('#c8302a') },
+        uFruitAmount: { value: 0.5 }, uRipeness: { value: 1 }, uFruitTint: { value: new THREE.Color('#ffffff') },
+    };
+    mat.userData.uniforms = own;
+    const PARS = `#include <common>\n${COMMON_VERT_PARS}
+uniform vec4 uFruitShape; uniform float uFruitAmount;
+attribute vec3 aSph; attribute vec3 aPos; attribute vec3 aRoot; attribute vec4 aInfo; attribute vec2 aWind;
+varying vec3 vFruit; varying vec2 vFruitUv;
+vec3 fruitShape(vec3 p, float h) {
+    // a unit sphere shaped per kind: stretched along y, tapered toward the top, dimpled at the poles
+    float y = p.y;
+    float taper = 1.0 - uFruitShape.z * smoothstep(-0.2, 1.0, y);
+    vec3 q = vec3(p.x * taper, y * uFruitShape.x, p.z * taper);
+    float pole = pow(max(abs(y), 0.0), 6.0);
+    q.y -= sign(y) * uFruitShape.y * pole * 0.35 * (y > 0.0 ? 1.0 : 0.6);
+    // slight individual lumpiness
+    q *= 1.0 + 0.03 * (vhash11(h * 9.0 + floor(p.x * 3.0 + p.z * 5.0 + 7.0)) - 0.5);
+    return q;
+}`;
+    const PRE = `
+    float keep = step(aInfo.w, uFruitAmount);
+    float sz = aInfo.x * uFruitShape.w * keep * 0.5 * uGrowth;
+    vec3 q0 = fruitShape(aSph, aInfo.y);
+    vec3 ap = aRoot + (aPos - aRoot) * uGrowth;`;
+    const NRM = `
+    vec3 objectNormal = isoNrm(normal / vec3(1.0, uFruitShape.x, 1.0));
+    #ifdef USE_TANGENT
+    vec3 objectTangent = vec3(tangent.xyz);
+    #endif`;
+    const POS = `
+    // hangs below its attachment and swings with the branch
+    vec3 hang = vec3(0.0, -sz * uFruitShape.x - 0.004, 0.0);
+    vec3 transformed = ap + isoOff(hang + q0 * sz) + plantDisplace(ap, aInfo.z, aWind) * uGrowth;
+    vFruit = vec3(aInfo.y, aInfo.z, aSph.y); vFruitUv = vec2(atan(aSph.z, aSph.x), aSph.y);`;
+    const vert = (shader, depth = false) => {
+        injectUniforms(shader, u);
+        injectUniforms(shader, own);
+        shader.vertexShader = depth
+            ? shader.vertexShader.replace('#include <common>', PARS).replace('#include <begin_vertex>', PRE + POS)
+            : shader.vertexShader.replace('#include <common>', PARS).replace('#include <beginnormal_vertex>', PRE + NRM).replace('#include <begin_vertex>', POS);
+    };
+    mat.onBeforeCompile = (shader) => {
+        vert(shader);
+        shader.fragmentShader = shader.fragmentShader
+            .replace('#include <common>', `#include <common>\n${VEG_UNIFORMS_GLSL}\n${NOISE_GLSL_V}
+uniform vec4 uFruitSkin; uniform vec3 uFruitUnripe, uFruitRipe, uFruitTint; uniform float uRipeness;
+varying vec3 vFruit; varying vec2 vFruitUv;`)
+            .replace('#include <roughnessmap_fragment>', '#include <roughnessmap_fragment>\n    roughnessFactor = vegRough;')
+            .replace('#include <map_fragment>', `
+    float vegRough = 0.5;
+    float h = vFruit.x;
+    // ripeness per fruit: the knob with a spread, so a tree ripens over a while, sun side first
+    float ripe = smoothstep(h * 0.6 - 0.1, h * 0.6 + 0.35, uRipeness * 1.2);
+    vec3 skin = mix(uFruitUnripe, uFruitRipe, ripe);
+    // blush streaks along the meridians, pores as fine speckle
+    float streak = fbm2v(vec2(vFruitUv.x * 2.5 + h * 10.0, vFruitUv.y * 3.0));
+    skin = mix(skin, uFruitRipe * 1.15, uFruitSkin.y * ripe * smoothstep(0.45, 0.7, streak) * 0.7);
+    skin = mix(skin, uFruitUnripe, uFruitSkin.y * (1.0 - ripe) * 0.3 * smoothstep(0.5, 0.7, streak));
+    float pores = vnoise2v(vec2(vFruitUv.x * 40.0, vFruitUv.y * 30.0) + h * 3.0);
+    skin *= 1.0 - uFruitSkin.z * 0.12 * pores;
+    diffuseColor.rgb *= skin * uFruitTint * (0.9 + 0.2 * vhash11(h * 4.0));
+    vegRough = mix(0.7, 0.2, uFruitSkin.x);`);
+        bakeOut(shader);
+    };
+    mat.customProgramCacheKey = () => 'veg-fruit';
+    const depth = new THREE.MeshDepthMaterial({ depthPacking: THREE.RGBADepthPacking });
+    depth.onBeforeCompile = (shader) => vert(shader, true);
+    depth.customProgramCacheKey = () => 'veg-fruit-depth';
+    return { material: mat, depth };
+}
+export function applyFruitConfig(mat, c) {
+    const o = mat.userData.uniforms;
+    if (c.fruit !== undefined) {
+        const p = FRUIT_PROFILES[c.fruit];
+        if (p) {
+            o.uFruitShape.value.set(p.elong, p.dimple, p.taper, p.size);
+            o.uFruitSkin.value.set(p.gloss, p.streaks, p.pores, 0);
+            o.uFruitUnripe.value.set(p.unripe);
+            o.uFruitRipe.value.set(p.ripe);
+        }
+        mat.visible = !!p;
+    }
+    if (c.fruitAmount !== undefined)
+        o.uFruitAmount.value = c.fruitAmount;
+    if (c.ripeness !== undefined)
+        o.uRipeness.value = c.ripeness;
+    if (c.fruitColor !== undefined)
+        setColor(o.uFruitTint, c.fruitColor);
+}
+export function fruitGeometry(count, detail) {
+    const sph = new THREE.SphereGeometry(1, detail || 12, detail ? Math.round(detail * 0.7) : 8);
+    const geo = new THREE.InstancedBufferGeometry();
+    // `position` is bounds only (the sphere fitted in the unit box); the shape reads aSph
+    const bp = new Float32Array(sph.attributes.position.array.length);
+    for (let i = 0; i < bp.length; i += 3) {
+        bp[i] = sph.attributes.position.array[i] * 0.5;
+        bp[i + 1] = sph.attributes.position.array[i + 1] * 0.5 + 0.5;
+        bp[i + 2] = sph.attributes.position.array[i + 2] * 0.5;
+    }
+    geo.setAttribute('position', new THREE.Float32BufferAttribute(bp, 3));
+    geo.setAttribute('aSph', sph.attributes.position);
+    geo.setAttribute('normal', sph.attributes.normal);
+    geo.setAttribute('uv', sph.attributes.uv);
+    geo.setIndex(sph.index);
+    geo.setAttribute('aPos', new THREE.InstancedBufferAttribute(new Float32Array(count * 3), 3));
+    geo.setAttribute('aRoot', new THREE.InstancedBufferAttribute(new Float32Array(count * 3), 3));
+    geo.setAttribute('aInfo', new THREE.InstancedBufferAttribute(new Float32Array(count * 4), 4));
+    geo.setAttribute('aWind', new THREE.InstancedBufferAttribute(new Float32Array(count * 2), 2));
+    geo.instanceCount = count;
+    return geo;
+}
+/** Fruit at a seeded subset of the outer leaves; `size` in unit space (fruit radius ≈ size/2 × profile size). */
+export function fillFruit(geo, leaves, rnd, size) {
+    const outer = leaves.filter((l) => l.ao > 0.45);
+    const n = geo.instanceCount;
+    for (let i = 0; i < n; i++) {
+        const l = outer.length ? outer[Math.floor(rnd() * outer.length)] : leaves[Math.floor(rnd() * leaves.length)];
+        geo.attributes.aPos.setXYZ(i, l.pos.x, l.pos.y, l.pos.z);
+        geo.attributes.aInfo.setXYZW(i, size * (0.8 + 0.4 * rnd()), rnd(), l.hf, rnd());
+        geo.attributes.aWind.setXY(i, l.phase, l.flex);
+        if (l.root)
+            geo.attributes.aRoot.setXYZ(i, l.root.x, l.root.y, l.root.z);
+    }
+    for (const k of ['aPos', 'aRoot', 'aInfo', 'aWind'])
+        geo.attributes[k].needsUpdate = true;
+}
+// ---------------------------------------------------------------------------- falling leaves
+/**
+ * Leaves letting go: a small instanced card layer. Each card cycles analytically — released from a
+ * canopy leaf's position, it falls with a side-to-side glide and a tumble, drifts with the wind,
+ * and fades at the ground; then starts again. `uLeafFall` says how many are
+ * in the air; the season releases more.
+ */
+export function fallingMaterial(u) {
+    const mat = new THREE.MeshStandardMaterial({ color: 0xffffff, roughness: 0.7, metalness: 0, side: THREE.DoubleSide, alphaToCoverage: true });
+    const own = { uLeafFall: { value: 0 }, uAutumnA: { value: new THREE.Color('#e2a21c') }, uAutumnB: { value: new THREE.Color('#b8441c') } };
+    mat.userData.uniforms = own;
+    const PARS = `#include <common>\n${COMMON_VERT_PARS}
+uniform float uLeafFall;
+attribute vec2 aCard; attribute vec3 aPos; attribute vec4 aQuat; attribute vec4 aInfoA; attribute vec4 aInfoB;
+varying vec2 vCard; varying vec4 vLeaf;`;
+    const PRE = `
+    float h = aInfoA.y;
+    float period = 6.0 + 6.0 * vhash11(h * 3.1);
+    float ph = fract(uTime / period + h);
+    // in the air when its order is under the fall rate (the season adds to it); fades in and out
+    float rate = uLeafFall + 0.6 * smoothstep(0.5, 1.0, uSeason);
+    float on = step(aInfoB.z, rate) * smoothstep(0.0, 0.08, ph) * (1.0 - smoothstep(0.88, 1.0, ph));
+    // glide: sideways pendulum with a tumble
+    float tumble = uTime * 2.5 + h * 20.0;
+    float ct = cos(tumble), st = sin(tumble);
+    vec3 lp = vec3(aCard.x * ct, aCard.y, aCard.x * st);
+    vec3 ln = vec3(-st, 0.0, ct);`;
+    const NRM = `
+    vec3 objectNormal = isoNrm(qrot(aQuat, ln));
+    #ifdef USE_TANGENT
+    vec3 objectTangent = vec3(tangent.xyz);
+    #endif`;
+    const POS = `
+    float fallH = aPos.y + 0.02;
+    float y = aPos.y - ph * fallH;
+    vec2 drift = uWindDir * uWindStrength * ph * fallH * 2.5;
+    vec2 glide = vec2(sin(ph * 14.0 + h * 9.0), cos(ph * 11.0 + h * 5.0)) * 0.04 * ph;
+    vec3 p = vec3(aPos.x + drift.x + glide.x, y, aPos.z + drift.y + glide.y);
+    float sz = aInfoA.x * uLeafSize * on;
+    vec3 transformed = p + isoOff(qrot(aQuat, lp * sz));
+    vCard = aCard; vLeaf = vec4(h, 1.0, 0.0, aInfoA.z);`;
+    const vert = (shader, depth = false) => {
+        injectUniforms(shader, u);
+        injectUniforms(shader, own);
+        shader.vertexShader = depth
+            ? shader.vertexShader.replace('#include <common>', PARS).replace('#include <begin_vertex>', PRE + POS)
+            : shader.vertexShader.replace('#include <common>', PARS).replace('#include <beginnormal_vertex>', PRE + NRM).replace('#include <begin_vertex>', POS);
+    };
+    const fragMask = `
+    float lsd = leafSdf(vCard, uLeafType, vLeaf.x);
+    float aa = fwidth(lsd) * 0.9;
+    float cover = 1.0 - smoothstep(-aa, aa, lsd);
+    if (cover < 0.02) discard;`;
+    mat.onBeforeCompile = (shader) => {
+        vert(shader);
+        shader.fragmentShader = shader.fragmentShader
+            .replace('#include <common>', `#include <common>\n${VEG_UNIFORMS_GLSL}\n${NOISE_GLSL_V}\n${LEAF_SDF_GLSL}\nuniform vec3 uAutumnA, uAutumnB; varying vec2 vCard; varying vec4 vLeaf;`)
+            .replace('#include <map_fragment>', `${fragMask}
+    float h = vLeaf.x;
+    // a leaf that lets go has turned: mostly autumn colours, a few still green
+    vec3 autumn = mix(uAutumnA, uAutumnB, vhash11(h * 5.0 + 3.0));
+    vec3 base = mix(uColor * 0.9, autumn, smoothstep(0.1, 0.4, vhash11(h * 2.0) + uSeason * 0.5));
+    diffuseColor.rgb *= base;
+    diffuseColor.a *= cover * uOpacity;`);
+        bakeOut(shader);
+    };
+    mat.customProgramCacheKey = () => 'veg-fall';
+    const depth = new THREE.MeshDepthMaterial({ depthPacking: THREE.RGBADepthPacking, side: THREE.DoubleSide });
+    depth.onBeforeCompile = (shader) => {
+        vert(shader, true);
+        shader.fragmentShader = shader.fragmentShader
+            .replace('#include <common>', `#include <common>\n${VEG_UNIFORMS_GLSL}\n${LEAF_SDF_GLSL}\nvarying vec2 vCard; varying vec4 vLeaf;`)
+            .replace('#include <map_fragment>', fragMask);
+    };
+    depth.customProgramCacheKey = () => 'veg-fall-depth';
+    return { material: mat, depth };
+}
+/** A shadow-casting mesh from a geometry and a { material, depth } pair; clicks pass through. */
+export function plantMesh(geo, pair, name) {
+    const mesh = new THREE.Mesh(geo, pair.material);
+    mesh.customDepthMaterial = pair.depth;
+    mesh.castShadow = true;
+    mesh.receiveShadow = true;
+    mesh.frustumCulled = false;
+    mesh.raycast = function () { };
+    mesh.name = name || '';
+    return mesh;
+}
+/** The quality table every plant uses: a multiplier on counts. */
+export const QUALITY_V = { low: 0.5, medium: 1, high: 1.8 };
+// ---------------------------------------------------------------------------- blades (grass, stems)
+/**
+ * Bent blades: one instanced strip (2 × SEG+1 vertices) per blade. Per instance: aPos (root), aInfoA =
+ * (height, width, yaw, hash), aInfoB = (bend, phase, order, kind). In the vertex the blade curves
+ * along its bend direction (quadratic, tip bends most), the wind field bends it further ∝ t²
+ * (plantDisplace with hf = t) plus a travelling ripple. The fragment
+ * shades a base-to-tip gradient with per-blade variation and translucency.
+ */
+export const BLADE_SEG = 6;
+export function bladeGeometry(count) {
+    const geo = new THREE.InstancedBufferGeometry();
+    const P = [], C = [], N = [], I = [];
+    for (let i = 0; i <= BLADE_SEG; i++) {
+        const t = i / BLADE_SEG;
+        // bounds-only positions (a thin box in the unit box); the blade is aCard = (side, t), three across so it folds
+        P.push(-0.5, t, -0.5, 0, t, 0, 0.5, t, 0.5);
+        C.push(-1, t, 0, t, 1, t);
+        N.push(0, 0, 1, 0, 0, 1, 0, 0, 1);
+        if (i < BLADE_SEG) {
+            const a = i * 3;
+            I.push(a, a + 1, a + 3, a + 1, a + 4, a + 3, a + 1, a + 2, a + 4, a + 2, a + 5, a + 4);
+        }
+    }
+    geo.setAttribute('position', new THREE.Float32BufferAttribute(P, 3));
+    geo.setAttribute('aCard', new THREE.Float32BufferAttribute(C, 2));
+    geo.setAttribute('normal', new THREE.Float32BufferAttribute(N, 3));
+    geo.setIndex(I);
+    geo.setAttribute('aPos', new THREE.InstancedBufferAttribute(new Float32Array(count * 3), 3));
+    geo.setAttribute('aInfoA', new THREE.InstancedBufferAttribute(new Float32Array(count * 4), 4));
+    geo.setAttribute('aInfoB', new THREE.InstancedBufferAttribute(new Float32Array(count * 4), 4));
+    geo.instanceCount = count;
+    unitBounds(geo);
+    return geo;
+}
+export function setBlade(geo, i, pos, height, width, yaw, hash, bend, phase, order, kind) {
+    geo.attributes.aPos.setXYZ(i, pos.x, pos.y, pos.z);
+    geo.attributes.aInfoA.setXYZW(i, height, width, yaw, hash);
+    geo.attributes.aInfoB.setXYZW(i, bend, phase, order, kind || 0);
+}
+export function bladeMaterial(u, opts) {
+    const o = Object.assign({ roughness: 0.6, translucency: 0.5, tipColor: null, taper: 1 }, opts);
+    const mat = new THREE.MeshStandardMaterial({ color: 0xffffff, roughness: o.roughness, metalness: 0, side: THREE.DoubleSide, envMapIntensity: 0.5 });
+    const own = { uTranslucency: { value: o.translucency }, uTaper: { value: o.taper }, uTipColor: { value: new THREE.Color(o.tipColor || '#9ccf5a') }, uTipMix: { value: o.tipColor ? 1 : 0 } };
+    mat.userData.uniforms = own;
+    const PARS = `#include <common>\n${COMMON_VERT_PARS}
+uniform float uTaper;
+attribute vec2 aCard; attribute vec3 aPos; attribute vec4 aInfoA; attribute vec4 aInfoB;
+varying vec2 vCard; varying vec4 vBlade;`;
+    const PRE = `
+    float t = aCard.y;
+    float keep = step(aInfoB.z, uFoliage);
+    float H = aInfoA.x * uGrowth * keep, Wd = aInfoA.y * uLeafSize * keep;
+    float cy = cos(aInfoA.z), sy = sin(aInfoA.z);
+    vec3 side = vec3(cy, 0.0, sy), fwd = vec3(-sy, 0.0, cy);
+    // the blade's own curve (quadratic along fwd), width tapering to the tip
+    float w = Wd * mix(1.0, 1.0 - 0.9 * t, uTaper) * (1.0 - 0.15 * t * t);
+    // the blade folds along its midrib (a gutter), so each half catches the light differently
+    float fold = 0.35 * (1.0 - aCard.x * aCard.x) * w;
+    // the blade stands and curves over only near its tip (t³), so the sward reads upright, not combed flat
+    float tc = t * t * t;
+    // sideways offsets are heights laid over: they must be in the height's metric, not the footprint's
+    // (a 6 m × 0.6 m box would otherwise turn a 30° lean into a 2 m sweep)
+    vec3 hk = vec3(uScale.y / uScale.x, 1.0, uScale.y / uScale.z);
+    vec3 p = aPos + vec3(0.0, H * t, 0.0) + fwd * aInfoB.x * H * tc * hk + isoOff(side * aCard.x * 0.5 * w - fwd * fold);
+    // wind: the field at the root, applied ∝ t² (the base is rooted), with a travelling ripple
+    vec3 d = plantDisplace(aPos + vec3(0.0, H, 0.0), 1.0, aInfoB.yy) * tc * 0.7 * hk;
+    float rip = sin(uTime * 2.2 + dot(aPos.xz, uWindDir) * 14.0 * uScale.x * 0.05 + aInfoB.y * 3.0) * uWindStrength * 0.08 * H * t * t;
+    p += d + vec3(uWindDir.x, 0.0, uWindDir.y) * rip * hk;
+    // a bent blade loses height
+    p.y -= length((d.xz + fwd.xz * aInfoB.x * H * tc * hk.xz) / hk.xz) * 0.5 * tc;
+    vec3 nrm = normalize(cross(side, normalize(vec3(fwd.x * aInfoB.x * 3.0 * t * t * H + d.x, H, fwd.z * aInfoB.x * 3.0 * t * t * H + d.z))));
+    nrm = normalize(nrm + side * aCard.x * 0.7);`;
+    const NRM = `
+    vec3 objectNormal = isoNrm(nrm);
+    #ifdef USE_TANGENT
+    vec3 objectTangent = vec3(tangent.xyz);
+    #endif`;
+    const POS = `
+    vec3 transformed = p;
+    vCard = aCard; vBlade = vec4(aInfoA.w, t, aInfoB.w, aPos.x + aPos.z * 1.7);`;
+    const vert = (shader, depth = false) => {
+        injectUniforms(shader, u);
+        injectUniforms(shader, own);
+        shader.vertexShader = depth
+            ? shader.vertexShader.replace('#include <common>', PARS).replace('#include <begin_vertex>', PRE + POS)
+            : shader.vertexShader.replace('#include <common>', PARS).replace('#include <beginnormal_vertex>', PRE + NRM).replace('#include <begin_vertex>', POS);
+    };
+    mat.onBeforeCompile = (shader) => {
+        vert(shader);
+        shader.fragmentShader = shader.fragmentShader
+            .replace('#include <common>', `#include <common>\n${VEG_UNIFORMS_GLSL}\n${NOISE_GLSL_V}
+uniform float uTranslucency, uTipMix; uniform vec3 uTipColor;
+varying vec2 vCard; varying vec4 vBlade;`)
+            .replace('#include <map_fragment>', `
+    float h = vBlade.x, t = vBlade.y;
+    // base in shade (the sward's own occlusion), tip in light; per-blade scatter; patches of yellower and
+    // bluer grass across the field (vBlade.w carries the root's x+z); a few dead straws
+    vec3 base = mix(uShadeColor, uColor, pow(smoothstep(0.0, 0.85, t), 1.4) * (0.75 + 0.45 * vhash11(h * 5.0)));
+    base = mix(base, base * vec3(1.05, 1.0, 0.85), vhash11(h * 3.0 + 1.0) * 0.5);
+    float ptch = vnoise2v(vec2(vBlade.w * 3.0, vBlade.w * 7.0 + h * 0.01));
+    base = mix(base * vec3(0.9, 0.98, 1.08), base * vec3(1.12, 1.05, 0.78), ptch);
+    float dead = step(0.96, vhash11(h * 11.0 + 2.0));
+    base = mix(base, vec3(0.62, 0.52, 0.28) * (0.8 + 0.4 * t), dead);
+    base = mix(base, uTipColor, uTipMix * smoothstep(0.6, 1.0, t));
+    vec3 dry = vec3(0.78, 0.66, 0.3) * (0.8 + 0.4 * vhash11(h * 7.0));
+    base = mix(base, dry, smoothstep(h * 0.6, h * 0.6 + 0.4, uSeason) * smoothstep(0.1, 0.9, t + uSeason * 0.5));
+    // midrib
+    base *= 1.0 + 0.1 * (1.0 - smoothstep(0.0, 0.25, abs(vCard.x)));
+    diffuseColor.rgb *= base;
+    diffuseColor.a *= uOpacity;`)
+            .replace('#include <lights_fragment_end>', `#include <lights_fragment_end>
+    {
+        float back = max(dot(-normal, uSunDirView), 0.0);
+        reflectedLight.indirectDiffuse += diffuseColor.rgb * back * uTranslucency * 0.8;
+    }`);
+    };
+    mat.customProgramCacheKey = () => 'veg-blade';
+    const depth = new THREE.MeshDepthMaterial({ depthPacking: THREE.RGBADepthPacking, side: THREE.DoubleSide });
+    depth.onBeforeCompile = (shader) => vert(shader, true);
+    depth.customProgramCacheKey = () => 'veg-blade-depth';
+    return { material: mat, depth };
+}
+/** Seeded positions over the unit footprint with clumping: jittered grid, kept where a clump noise says so. */
+export function clumpedPositions(count, rnd, clumping, margin) {
+    const out = [];
+    const m = margin || 0;
+    const side = Math.ceil(Math.sqrt(count * 1.6));
+    const cells = [];
+    for (let j = 0; j < side; j++)
+        for (let i = 0; i < side; i++)
+            cells.push([i, j]);
+    // shuffle cells, then take the ones the clump field admits
+    for (let i = cells.length - 1; i > 0; i--) {
+        const j = Math.floor(rnd() * (i + 1));
+        const t = cells[i];
+        cells[i] = cells[j];
+        cells[j] = t;
+    }
+    const f1 = 2 + rnd() * 2, f2 = 5 + rnd() * 3, o1 = rnd() * 10, o2 = rnd() * 10;
+    for (const [i, j] of cells) {
+        if (out.length >= count)
+            break;
+        const x = -0.5 + m + (1 - 2 * m) * (i + rnd()) / side, z = -0.5 + m + (1 - 2 * m) * (j + rnd()) / side;
+        const nz = 0.5 + 0.5 * Math.sin(x * f1 * 6.28 + o1) * Math.cos(z * f1 * 6.28 + o2) + 0.25 * Math.sin((x + z) * f2 * 6.28 + o1);
+        if (rnd() < 1 - clumping + clumping * nz)
+            out.push(new THREE.Vector3(x, 0, z));
+    }
+    while (out.length < count)
+        out.push(new THREE.Vector3(-0.5 + m + (1 - 2 * m) * rnd(), 0, -0.5 + m + (1 - 2 * m) * rnd()));
+    return out;
+}
+// ---------------------------------------------------------------------------- flower heads on woody plants
+/**
+ * Flower heads at branch tips (blossom on trees, flowers on shrubs): each head is a fan of petal cards
+ * around the tip (a `head` of several florets scattered in a small dome for panicles), coloured by its
+ * own uniforms. `uFoliage` of the head material is the flowers knob (0..1 keeps that share of heads).
+ * spec: { petals, size, color, head?, type?, hang? }. Returns { geo, pair, U } (U.uFoliage / U.uColor).
+ */
+export function flowerHeads(u, tips, rnd, spec, maxHeads, matOpts = undefined) {
+    const petals = spec.petals || 5, head = spec.head || 1, type = spec.type || 'petal';
+    const U = Object.assign({}, u, { uLeafType: { value: LEAF_TYPES.indexOf(type) }, uColor: { value: new THREE.Color(spec.color) }, uShadeColor: { value: new THREE.Color(spec.color).multiplyScalar(0.6) }, uFoliage: { value: 1 }, uSeason: { value: 0 }, uLeafSize: { value: 1 } });
+    const nHeads = Math.min(tips.length, maxHeads);
+    const geo = leafGeometry(Math.max(1, nHeads * petals * head));
+    const up = new THREE.Vector3(0, 1, 0), along = new THREE.Vector3(), nrm = new THREE.Vector3(), perp = new THREE.Vector3(), pos = new THREE.Vector3();
+    let fi = 0;
+    for (let h = 0; h < nHeads; h++) {
+        const b = tips[Math.floor(rnd() * tips.length)];
+        const tipP = b.pts[b.pts.length - 1], t = spec.hang ? new THREE.Vector3(0, -1, 0) : (b.tip || new THREE.Vector3().subVectors(tipP, b.pts[Math.max(0, b.pts.length - 2)]).normalize());
+        const order = h / nHeads;
+        for (let k = 0; k < head; k++) {
+            perp.crossVectors(t, Math.abs(t.y) < 0.9 ? up : new THREE.Vector3(1, 0, 0)).normalize().applyAxisAngle(t, rnd() * Math.PI * 2);
+            pos.copy(tipP).addScaledVector(perp, head > 1 ? rnd() * spec.size * 2.5 : 0).addScaledVector(t, head > 1 ? rnd() * spec.size * 2 : spec.size * 0.3);
+            for (let p = 0; p < petals; p++) {
+                const a = (p + rnd() * 0.3) / petals * Math.PI * 2;
+                along.copy(perp).applyAxisAngle(t, a).multiplyScalar(1 - (spec.cup || 0.3)).addScaledVector(t, spec.cup || 0.3).normalize();
+                nrm.copy(t).addScaledVector(along, -0.3).normalize();
+                setLeaf(geo, fi++, pos, along, nrm, spec.size * (0.8 + 0.4 * rnd()), rnd(), Math.min(1, pos.y), 0.9, b.phase, b.flex, order, 0);
+                if (b.root)
+                    setLeafRoot(geo, fi - 1, b.root);
+            }
+        }
+    }
+    geo.instanceCount = fi;
+    for (const k of ['aPos', 'aRoot', 'aQuat', 'aInfoA', 'aInfoB'])
+        geo.attributes[k].needsUpdate = true;
+    unitBounds(geo);
+    const pair = leafMaterial(U, Object.assign({ translucency: 0.7, veins: 0, roughness: 0.9, underside: 0.05, curl: 0.5 }, matOpts));
+    pair.material.envMapIntensity = 0.2;
+    return { geo, pair, U };
+}
+// ---------------------------------------------------------------------------- detail levels (CPU) + impostor
+const _lsm = (a, b, x) => { const t = Math.min(1, Math.max(0, (x - a) / (b - a))); return t * t * (3 - 2 * t); };
+/** The plant's screen size s from a drawn mesh's matrixWorld — the same formula as vegLodS (GLSL). */
+export function lodScreenSize(m, u) {
+    if (u.uBake.value > 0.5)
+        return 1e6;
+    const e = m.elements;
+    const cx = e[4] * 0.5 + e[12], cy = e[5] * 0.5 + e[13], cz = e[6] * 0.5 + e[14];
+    const R = 0.5 * Math.sqrt(e[0] * e[0] + e[1] * e[1] + e[2] * e[2] + e[4] * e[4] + e[5] * e[5] + e[6] * e[6] + e[8] * e[8] + e[9] * e[9] + e[10] * e[10]);
+    const v = u.uViewPos.value;
+    const d = u.uLodOrtho.value > 0.5 ? 1 : Math.max(Math.hypot(cx - v.x, cy - v.y, cz - v.z), 1e-3);
+    return R * u.uLodK.value / d * u.uLodBias.value;
+}
+/** The share of the leaves drawn at screen size s (vegLodFrac). */
+export function lodFrac(s) { return LOD.MIN + (1 - LOD.MIN) * _lsm(LOD.IMP, LOD.FULL, s); }
+/** The lod knob: auto (by distance), full (never reduce — a hero plant), impostor (always the far card). */
+export const LOD_MODES = ['auto', 'full', 'impostor'];
+export function applyLodMode(u, mode) { u.uLodBias.value = mode === 'full' ? 1e6 : mode === 'impostor' ? 1e-6 : 1; }
+/** Leaves in a random order (own stream, so the plant's other random draws are unchanged): drawing the first K is an even thinning. */
+export function lodOrder(list, seed) {
+    const r = mulberry32((seed || 1) * 7919 + 13), a = list.slice();
+    for (let i = a.length - 1; i > 0; i--) {
+        const j = Math.floor(r() * (i + 1));
+        const t = a[i];
+        a[i] = a[j];
+        a[j] = t;
+    }
+    return a;
+}
+/**
+ * The per-draw decision for one part. Runs in onBeforeRender / onBeforeShadow of the part AND of every
+ * mirror of it (layouts copy the callbacks), so it reads only the drawn object's matrixWorld and writes
+ * only draw state of the shared geometry (instanceCount, drawRange), which the renderer reads right after.
+ */
+function lodDrawFn(st, role, geo) {
+    const full = geo.instanceCount || 0;
+    const idxAll = geo.index ? geo.index.count : Infinity;
+    const ends = geo.userData.levelEnds;
+    return (obj, shadow) => {
+        const s = lodScreenSize(obj.matrixWorld, st.u);
+        if (s < LOD.IMP * 1.6)
+            st.wanted = true;
+        const dr = geo.drawRange;
+        dr.start = 0;
+        if (role === 'impostor') {
+            dr.count = st.ready && s < LOD.IMP * (shadow ? 1 : LOD.FADE_IN) ? Infinity : 0;
+            return;
+        }
+        if (st.ready && s < LOD.IMP * (shadow ? 1 : LOD.FADE_OUT)) {
+            dr.count = 0;
+            return;
+        }
+        if (role === 'leaves') {
+            geo.instanceCount = Math.min(full, Math.ceil(full * lodFrac(s) * (shadow ? LOD.SHADOW : 1)));
+            const flat = shadow || s < LOD.FLAT;
+            dr.start = flat ? CARD_IDX : 0;
+            dr.count = flat ? FLAT_IDX : CARD_IDX;
+        }
+        else if (role === 'bark' && ends && ends.length > 1) {
+            dr.count = shadow ? ends[1] : s < LOD.FLAT ? ends[ends.length - 2] : idxAll;
+        }
+        else
+            dr.count = Infinity;
+    };
+}
+const LOD_SPHERE = new THREE.Sphere(new THREE.Vector3(0, 0.5, 0), 1.0); // the unit box with room for the wind
+const LOD_CULLED = new THREE.Sphere(new THREE.Vector3(), -1e9); // intersects no frustum
+/**
+ * Installs the detail decision on a part and on every copy of it. A part whose tier needs nothing from it
+ * is frustum-culled through a per-object bounding sphere (Frustum.intersectsObject reads
+ * object.boundingSphere when the object has one), so the renderer never sets it up — an emptied draw
+ * range still costs a program / uniform setup per draw. Inside the bands, onBeforeRender / onBeforeShadow
+ * trim the shared geometry's draw range and instance count. Layout mirrors call userData.mirrorSetup.
+ */
+function lodAttach(mesh, fn, st, role) {
+    const install = (obj) => {
+        obj.onBeforeRender = function () { fn(this, false); };
+        obj.onBeforeShadow = function (renderer, object) { fn(object, true); };
+        obj.frustumCulled = true;
+        Object.defineProperty(obj, 'boundingSphere', {
+            configurable: true,
+            get() {
+                if (!st.ready)
+                    return LOD_SPHERE;
+                const s = lodScreenSize(this.matrixWorld, st.u);
+                if (s < LOD.IMP * 1.6)
+                    st.wanted = true;
+                const off = role === 'impostor' ? s >= LOD.IMP * LOD.FADE_IN : s < LOD.IMP * LOD.FADE_OUT;
+                return off ? LOD_CULLED : LOD_SPHERE;
+            },
+        });
+    };
+    mesh.geometry.boundingSphere = LOD_SPHERE.clone();
+    mesh.userData.mirrorSetup = install;
+    install(mesh);
+}
+/**
+ * The impostor card: one quad billboarded toward the camera in the vertex shader (toward the light in the
+ * shadow pass — the depth material runs the same code with the shadow camera), textured from the 8×8
+ * hemi-octahedral atlas: the view direction in the plant's own frame picks the three nearest baked views
+ * and their weights; each pixel of the card is projected onto each view's plane (no parallax: fine at the
+ * distances it is drawn) and the three samples are blended. Albedo + plant-space normal, so the scene's sun
+ * lights it like the plant. `position` holds unit-box corners (gizmo bounds); the card is aCorner.
+ */
+export const IMP_N = 8, IMP_FRAME = 128, IMP_CHUNK = 16, IMP_MARGIN = 1.04;
+function impostorGeometry() {
+    const geo = new THREE.BufferGeometry();
+    geo.setAttribute('position', new THREE.Float32BufferAttribute([-0.5, 0, -0.5, 0.5, 0, 0.5, 0.5, 1, -0.5, -0.5, 1, 0.5], 3));
+    geo.setAttribute('aCorner', new THREE.Float32BufferAttribute([-1, -1, 1, -1, 1, 1, -1, 1], 2));
+    geo.setAttribute('normal', new THREE.Float32BufferAttribute([0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1], 3));
+    geo.setIndex([0, 1, 2, 0, 2, 3]);
+    return geo;
+}
+const IMP_PARS_V = /* glsl */ `
+uniform float uImpGrid, uImpR; uniform vec3 uImpScale;
+attribute vec2 aCorner;
+#ifdef USE_INSTANCING
+attribute float aImpSlot;
+#endif
+varying vec3 vImpP, vImpC, vAx0, vAx1, vAx2, vJit, vFW, vCamL, vToCamL; varying vec4 vF01; varying vec2 vF2; varying float vImpFade;`;
+const IMP_VERT = /* glsl */ `
+    mat4 IM = VEG_M;
+    vec3 ic = (IM * vec4(0.0, 0.5, 0.0, 1.0)).xyz;
+    vec3 a0 = IM[0].xyz, a1 = IM[1].xyz, a2 = IM[2].xyz;
+    vec3 al = vec3(length(a0), length(a1), length(a2));
+    vJit = al / uImpScale;                       // this copy's scale over the baked one (layout jitter; 1 for the plant itself)
+    vAx0 = a0 / al.x; vAx1 = a1 / al.y; vAx2 = a2 / al.z;
+    float Rw = uImpR * max(vJit.x, max(vJit.y, vJit.z));
+    vec3 camU = vec3(viewMatrix[0][1], viewMatrix[1][1], viewMatrix[2][1]);
+    vec3 camB = vec3(viewMatrix[0][2], viewMatrix[1][2], viewMatrix[2][2]);
+    vec3 toCam = isOrthographic ? camB : normalize(cameraPosition - ic);
+    vec3 bu = camU - toCam * dot(camU, toCam);
+    bu = dot(bu, bu) > 1e-8 ? normalize(bu) : normalize(cross(toCam, vec3(1.0, 0.0, 0.0)));
+    vec3 br = normalize(cross(bu, toCam));
+    vec3 P = ic + (br * aCorner.x + bu * aCorner.y) * Rw;
+    // sway: the plant's own wind field at the card's height (unit space → world)
+    float hfI = clamp(dot(P - IM[3].xyz, vAx1) / al.y, 0.0, 1.0);
+    P += mat3(IM) * plantDisplace(vec3(0.0, hfI, 0.0), hfI, vec2(0.5, 0.35));
+    vImpP = P; vImpC = ic;
+    // the view direction in the plant's frame → hemi-octahedral grid → the three views around it, barycentric weights
+    vec3 vd = vec3(dot(toCam, vAx0), max(dot(toCam, vAx1), 0.0), dot(toCam, vAx2));
+    vd /= max(abs(vd.x) + abs(vd.y) + abs(vd.z), 1e-5);
+    vec2 g = (vec2(vd.x - vd.z, -vd.x - vd.z) * 0.5 + 0.5) * (uImpGrid - 1.0);
+    vec2 cl = clamp(floor(g), 0.0, uImpGrid - 2.0);
+    vec2 fr = clamp(g - cl, 0.0, 1.0);
+    if (fr.x + fr.y < 1.0) { vF01 = vec4(cl, cl + vec2(1.0, 0.0)); vF2 = cl + vec2(0.0, 1.0); vFW = vec3(1.0 - fr.x - fr.y, fr.x, fr.y); }
+    else { vF01 = vec4(cl + vec2(1.0), cl + vec2(0.0, 1.0)); vF2 = cl + vec2(1.0, 0.0); vFW = vec3(fr.x + fr.y - 1.0, 1.0 - fr.x, 1.0 - fr.y); }
+    // the camera in the plant's (baked) frame: the fragment casts the view ray from it to reproject per view
+    vec3 cw = cameraPosition - ic;
+    vCamL = vec3(dot(cw, vAx0), dot(cw, vAx1), dot(cw, vAx2)) / vJit;
+    vToCamL = normalize(vec3(dot(toCam, vAx0), dot(toCam, vAx1), dot(toCam, vAx2)) / vJit);
+    vImpFade = vegLodFade(vegLodS());
+#ifdef USE_INSTANCING
+    // a forest: only the trees drawn in full detail this frame (aImpSlot = 1) cross-fade; every other one is the card
+    if (aImpSlot < 0.5) vImpFade = 1.0;
+#endif
+    vec3 transformed = (inverse(IM) * vec4(P, 1.0)).xyz;`;
+const IMP_PARS_F = /* glsl */ `
+uniform sampler2D uImpC, uImpN; uniform float uImpGrid, uImpR; uniform vec3 uImpScale;
+varying vec3 vImpP, vImpC, vAx0, vAx1, vAx2, vJit, vFW, vCamL, vToCamL; varying vec4 vF01; varying vec2 vF2; varying float vImpFade;
+// the baked view (i, j): direction (hemi-octahedral decode), image plane, framing (the box's half-extents in
+// that view, = the bake's) and half-depth along it
+struct ImpView { vec2 fr; vec3 r; vec3 up; vec3 d; float rf; float rd; };
+ImpView impView(vec2 fr) {
+    vec2 c = fr / (uImpGrid - 1.0) * 2.0 - 1.0;
+    vec3 d = vec3((c.x - c.y) * 0.5, 0.0, (-c.x - c.y) * 0.5);
+    d.y = 1.0 - abs(d.x) - abs(d.z);
+    d = normalize(d);
+    vec3 r = normalize(cross(vec3(0.0, 1.0, 0.0), d)), up = cross(d, r);
+    vec3 H = uImpScale * 0.5;
+    return ImpView(fr, r, up, d, max(dot(abs(r), H), dot(abs(up), H)) * ${IMP_MARGIN.toFixed(3)}, dot(abs(d), H) * ${IMP_MARGIN.toFixed(3)});
+}
+// atlas uv in xy; z = 1 inside this view's frame, 0 outside (outside is empty — never the frame's border repeated)
+vec3 impAt(ImpView v, vec3 L) {
+    vec2 q = vec2(dot(L, v.r), dot(L, v.up)) / (2.0 * v.rf) + 0.5;
+    float inside = step(0.0, q.x) * step(q.x, 1.0) * step(0.0, q.y) * step(q.y, 1.0);
+    return vec3((v.fr + clamp(q, 0.004, 0.996)) / uImpGrid, inside);
+}
+// parallax: the card pixel L is a point on the view ray, not the surface. Read this view's depth where L
+// lands, move along the ray to that depth, sample there — so the three views agree on where the surface is
+vec3 impReproject(ImpView v, vec3 L, vec3 ray) {
+    float dd = (texture2D(uImpN, impAt(v, L).xy).a - 0.5) * 2.0 * v.rd;
+    float k = dot(ray, v.d);
+    float t = abs(k) > 0.02 ? clamp((dd - dot(L, v.d)) / k, -3.0 * v.rd, 3.0 * v.rd) : 0.0;
+    return impAt(v, L + ray * t);
+}
+vec3 impLocal() { vec3 w = vImpP - vImpC; return vec3(dot(w, vAx0), dot(w, vAx1), dot(w, vAx2)) / vJit; }`;
+const IMP_ALPHA = /* glsl */ `
+    vec3 impL = impLocal();
+    vec3 impRay = isOrthographic ? -vToCamL : normalize(impL - vCamL);
+    vec3 iu0 = impReproject(impView(vF01.xy), impL, impRay), iu1 = impReproject(impView(vF01.zw), impL, impRay), iu2 = impReproject(impView(vF2), impL, impRay);
+    vec4 ic0 = texture2D(uImpC, iu0.xy), ic1 = texture2D(uImpC, iu1.xy), ic2 = texture2D(uImpC, iu2.xy);
+    ic0.a *= iu0.z; ic1.a *= iu1.z; ic2.a *= iu2.z;
+    // coverage: the weighted views (reprojected, so they agree), leaning a little toward the union so the
+    // crown does not thin where a far view barely misses
+    float impA = mix(ic0.a * vFW.x + ic1.a * vFW.y + ic2.a * vFW.z, max(ic0.a * vFW.x, max(ic1.a * vFW.y, ic2.a * vFW.z)) / max(max(vFW.x, vFW.y), vFW.z), 0.35);`;
+export function impostorMaterial(u) {
+    const mat = new THREE.MeshStandardMaterial({ color: 0xffffff, roughness: 0.8, metalness: 0, alphaToCoverage: true, envMapIntensity: 0.4 });
+    // the shadow card faces the light: three would draw a front-sided material back-faced in the shadow pass
+    mat.shadowSide = THREE.DoubleSide;
+    const own = { uImpC: { value: null }, uImpN: { value: null }, uImpGrid: { value: IMP_N }, uImpR: { value: 1 }, uImpScale: { value: new THREE.Vector3(1, 1, 1) } };
+    mat.userData.uniforms = own;
+    const vert = (shader) => {
+        injectUniforms(shader, u);
+        injectUniforms(shader, own);
+        shader.vertexShader = shader.vertexShader
+            .replace('#include <common>', `#include <common>\n${COMMON_VERT_PARS}\n${IMP_PARS_V}`)
+            .replace('#include <begin_vertex>', IMP_VERT);
+    };
+    mat.onBeforeCompile = (shader) => {
+        vert(shader);
+        shader.fragmentShader = shader.fragmentShader
+            .replace('#include <common>', `#include <common>\n${VEG_UNIFORMS_GLSL}\n${LOD_GLSL_F}\n${IMP_PARS_F}`)
+            .replace('#include <map_fragment>', `${IMP_ALPHA}
+    if (impA < 0.42) discard;
+    if (vImpFade < 1.0 && vegIgn(gl_FragCoord.xy) >= vImpFade) discard;
+    // the colour weighted by coverage too, so a view where this pixel is empty does not darken it
+    vec3 iw = vec3(ic0.a * vFW.x, ic1.a * vFW.y, ic2.a * vFW.z);
+    float iws = max(iw.x + iw.y + iw.z, 1e-4);
+    vec3 impAlb = (ic0.rgb * iw.x + ic1.rgb * iw.y + ic2.rgb * iw.z) / iws;
+    vec3 impNl = (texture2D(uImpN, iu0.xy).rgb * iw.x + texture2D(uImpN, iu1.xy).rgb * iw.y + texture2D(uImpN, iu2.xy).rgb * iw.z) / iws;
+    impNl = normalize(impNl * 2.0 - 1.0);
+    vec3 impNView = normalize((viewMatrix * vec4(vAx0 * impNl.x + vAx1 * impNl.y + vAx2 * impNl.z, 0.0)).xyz);
+    diffuseColor.rgb *= impAlb;
+    diffuseColor.a *= smoothstep(0.42, 0.62, impA) * uOpacity;`)
+            .replace('#include <normal_fragment_maps>', '#include <normal_fragment_maps>\n    normal = impNView;')
+            .replace('#include <lights_fragment_end>', `#include <lights_fragment_end>
+    // the leaves' translucency, approximated: sun through the crown when it is behind it
+    reflectedLight.indirectDiffuse += diffuseColor.rgb * vec3(1.05, 1.1, 0.7) * max(dot(-normal, uSunDirView), 0.0) * 0.5;`);
+    };
+    mat.customProgramCacheKey = () => 'veg-impostor';
+    const depth = new THREE.MeshDepthMaterial({ depthPacking: THREE.RGBADepthPacking });
+    depth.onBeforeCompile = (shader) => {
+        vert(shader);
+        shader.fragmentShader = shader.fragmentShader
+            .replace('#include <common>', `#include <common>\n${VEG_UNIFORMS_GLSL}\n${IMP_PARS_F}`)
+            .replace('#include <map_fragment>', `${IMP_ALPHA}\n    if (impA < 0.5) discard;`);
+    };
+    depth.customProgramCacheKey = () => 'veg-impostor-depth';
+    return { material: mat, depth, own };
+}
+/** Hemi-octahedral view (i, j) of an n×n grid: the unit direction toward the camera, y ≥ 0 (= impUV's decode). */
+function impFrameDir(i, j, n, out) {
+    const cx = i / (n - 1) * 2 - 1, cy = j / (n - 1) * 2 - 1;
+    const x = (cx - cy) * 0.5, z = (-cx - cy) * 0.5;
+    return out.set(x, 1 - Math.abs(x) - Math.abs(z), z).normalize();
+}
+const _iUp = new THREE.Vector3(0, 1, 0), _iD = new THREE.Vector3(), _iR = new THREE.Vector3(), _iU = new THREE.Vector3(), _iC = new THREE.Vector3(), _iCol = new THREE.Color();
+/**
+ * Detail levels for one plant: per-draw part reduction + the impostor (baked lazily, only once some draw
+ * of the plant is far enough to want it; re-baked progressively — IMP_CHUNK views per frame — when the
+ * plant's look or scale changes, at most every 1.5 s while it keeps changing).
+ *   parts.leaves   leaf-card meshes (fewer, grown, flat at distance)
+ *   parts.bark     branch meshes (finest level dropped at distance; trunk + level 0 in the shadow pass)
+ *   parts.other    meshes drawn until the impostor takes over (fruit, falling leaves)
+ *   parts.bake     the meshes the impostor shows (not the falling leaves)
+ *   parts.visible  [mesh, () => boolean]: parts hidden when they would draw nothing (blossom at 0, …)
+ * Returns { impostor, update(dt, renderer), applied(cfg), dispose() }.
+ */
+const LOOK_IGNORE = new Set(['speed', 'windStrength', 'windDirection', 'turbulence', 'flutter', 'sway', 'lod', 'leafFall', 'opacity', 'enabled', 'quality', 'seed']);
+export function plantLod(u, object, parts) {
+    const st = { u, ready: false, wanted: false, dirty: true, changedAt: 0, lastBake: -1e9, t: 0, frame: -1, key: '', bakeScale: new THREE.Vector3(), rtC: null, rtN: null };
+    for (const m of parts.leaves || [])
+        lodAttach(m, lodDrawFn(st, 'leaves', m.geometry), st, 'leaves');
+    for (const m of parts.bark || [])
+        lodAttach(m, lodDrawFn(st, 'bark', m.geometry), st, 'bark');
+    for (const m of parts.other || [])
+        lodAttach(m, lodDrawFn(st, 'other', m.geometry), st, 'other');
+    const imp = impostorMaterial(u);
+    const impGeo = impostorGeometry();
+    const impostor = plantMesh(impGeo, imp, 'impostor');
+    // casts (its card turns to the sun in the shadow pass) but does not receive: the card the camera sees and
+    // the card the sun sees cross, so it would shadow itself along their intersection. Its baked normals still
+    // give it a lit and a shaded side; at the distances it is drawn, other objects' shadows on it are not missed.
+    impostor.receiveShadow = false;
+    lodAttach(impostor, lodDrawFn(st, 'impostor', impGeo), st, 'impostor');
+    object.add(impostor);
+    // the bake scene: proxies sharing each part's geometry and material, drawn at full detail, unrotated, at the plant's scale
+    const scene = new THREE.Scene();
+    const proxies = (parts.bake || []).map((src) => {
+        const g = src.geometry, full = g.instanceCount, card = !!g.isInstancedBufferGeometry && g.index && g.index.count === CARD_IDX + FLAT_IDX;
+        const p = new THREE.Mesh(g, src.material);
+        p.matrixAutoUpdate = false;
+        p.frustumCulled = false;
+        p.onBeforeRender = function () { if (card) {
+            g.instanceCount = full;
+            g.drawRange.start = 0;
+            g.drawRange.count = CARD_IDX;
+        }
+        else {
+            g.drawRange.start = 0;
+            g.drawRange.count = Infinity;
+        } };
+        scene.add(p);
+        return { p, src };
+    });
+    const cam = new THREE.OrthographicCamera(-1, 1, 1, -1, 0.01, 10);
+    cam.matrixAutoUpdate = false;
+    function markDirty() { st.dirty = true; st.changedAt = st.t; }
+    function makeTarget() {
+        const size = IMP_N * IMP_FRAME;
+        const rt = new THREE.WebGLRenderTarget(size, size, { colorSpace: THREE.SRGBColorSpace, generateMipmaps: true, minFilter: THREE.LinearMipmapLinearFilter, magFilter: THREE.LinearFilter, depthBuffer: true });
+        return rt;
+    }
+    function bakeChunk(renderer) {
+        if (!st.rtC) {
+            st.rtC = makeTarget();
+            st.rtN = makeTarget();
+            // allocate with a mip chain now; mips are then generated once, after the last view
+            if (renderer.initRenderTarget) {
+                renderer.initRenderTarget(st.rtC);
+                renderer.initRenderTarget(st.rtN);
+            }
+            imp.own.uImpC.value = st.rtC.texture;
+            imp.own.uImpN.value = st.rtN.texture;
+        }
+        const S = st.bakeScale, R = 0.5 * S.length();
+        if (st.frame === 0) {
+            imp.own.uImpR.value = R;
+            imp.own.uImpScale.value.copy(S);
+        }
+        const prevRT = renderer.getRenderTarget(), prevAuto = renderer.autoClear, prevAlpha = renderer.getClearAlpha();
+        renderer.getClearColor(_iCol);
+        const pr = _iCol.r, pg = _iCol.g, pb = _iCol.b;
+        const prevShadowAuto = renderer.shadowMap.autoUpdate;
+        const saved = [u.uWindStrength.value, u.uFlutter.value, u.uOpacity.value, u.uBake.value];
+        u.uWindStrength.value = 0;
+        u.uFlutter.value = 0;
+        u.uOpacity.value = 1;
+        renderer.shadowMap.autoUpdate = false;
+        renderer.autoClear = true;
+        for (const { p, src } of proxies) {
+            p.matrix.makeScale(S.x, S.y, S.z);
+            p.visible = src.visible;
+        }
+        scene.updateMatrixWorld(true);
+        cam.near = 0.01 * R;
+        cam.far = 4 * R;
+        _iC.set(0, 0.5 * S.y, 0);
+        const total = IMP_N * IMP_N, end = Math.min(st.frame + IMP_CHUNK, total);
+        for (let f = st.frame; f < end; f++) {
+            const i = f % IMP_N, j = Math.floor(f / IMP_N);
+            impFrameDir(i, j, IMP_N, _iD);
+            _iR.crossVectors(_iUp, _iD).normalize();
+            _iU.crossVectors(_iD, _iR);
+            const Rf = Math.max(Math.abs(_iR.x) * S.x + Math.abs(_iR.y) * S.y + Math.abs(_iR.z) * S.z, Math.abs(_iU.x) * S.x + Math.abs(_iU.y) * S.y + Math.abs(_iU.z) * S.z) * 0.5 * IMP_MARGIN;
+            cam.left = -Rf;
+            cam.right = Rf;
+            cam.top = Rf;
+            cam.bottom = -Rf;
+            cam.updateProjectionMatrix();
+            u.uBakeDepth.value.set(2 * R, (Math.abs(_iD.x) * S.x + Math.abs(_iD.y) * S.y + Math.abs(_iD.z) * S.z) * 0.5 * IMP_MARGIN);
+            cam.matrix.makeBasis(_iR, _iU, _iD).setPosition(_iC.x + _iD.x * 2 * R, _iC.y + _iD.y * 2 * R, _iC.z + _iD.z * 2 * R);
+            cam.updateMatrixWorld(true);
+            u.uBakeView.value.setFromMatrix4(cam.matrixWorld);
+            for (let pass = 1; pass <= 2; pass++) {
+                const rt = pass === 1 ? st.rtC : st.rtN;
+                // empty pixels carry a foliage colour / an upward normal, so filtering at the silhouette does not fringe dark
+                if (pass === 1)
+                    renderer.setClearColor(u.uShadeColor.value, 0);
+                else
+                    renderer.setClearColor(_iCol.setRGB(0.5, 1, 0.5), 0);
+                rt.texture.generateMipmaps = f === total - 1;
+                rt.viewport.set(i * IMP_FRAME, j * IMP_FRAME, IMP_FRAME, IMP_FRAME);
+                rt.scissor.set(i * IMP_FRAME, j * IMP_FRAME, IMP_FRAME, IMP_FRAME);
+                rt.scissorTest = true;
+                u.uBake.value = pass;
+                renderer.setRenderTarget(rt);
+                renderer.render(scene, cam);
+            }
+        }
+        [u.uWindStrength.value, u.uFlutter.value, u.uOpacity.value, u.uBake.value] = saved;
+        renderer.shadowMap.autoUpdate = prevShadowAuto;
+        renderer.autoClear = prevAuto;
+        renderer.setClearColor(_iCol.setRGB(pr, pg, pb), prevAlpha);
+        renderer.setRenderTarget(prevRT);
+        st.frame = end >= total ? -1 : end;
+        if (st.frame < 0) {
+            st.ready = true;
+            u.uImpReady.value = 1;
+            st.lastBake = st.t;
+        }
+    }
+    return {
+        impostor,
+        state: st,
+        /** Per frame, after updateCommon: hides empty parts, bakes when wanted and stale. */
+        update(dt, renderer) {
+            st.t += dt || 0;
+            for (const [m, test] of parts.visible || [])
+                m.visible = !!test();
+            const sc = u.uScale.value;
+            if (st.ready && Math.abs(sc.x / st.bakeScale.x - 1) + Math.abs(sc.y / st.bakeScale.y - 1) + Math.abs(sc.z / st.bakeScale.z - 1) > 0.03)
+                markDirty();
+            if (renderer && st.frame < 0 && st.dirty && st.wanted && (st.t - st.changedAt > 0.3 || st.t - st.lastBake > 1.5)) {
+                st.dirty = false;
+                st.frame = 0;
+                st.bakeScale.copy(sc);
+            }
+            if (renderer && st.frame >= 0)
+                bakeChunk(renderer);
+            st.wanted = false; // re-armed by this frame's draws
+        },
+        /** After every apply: the lod knob, and a re-bake when a knob that changes the look moved. */
+        applied(cfg) {
+            if (cfg.lod !== undefined)
+                applyLodMode(u, cfg.lod);
+            let key = '';
+            for (const k in cfg)
+                if (!LOOK_IGNORE.has(k)) {
+                    const v = cfg[k];
+                    key += k + ':' + (v && v.isColor ? v.getHexString() : typeof v === 'number' ? v.toFixed(3) : v) + ';';
+                }
+            if (key !== st.key) {
+                st.key = key;
+                markDirty();
+            }
+        },
+        dispose() {
+            impGeo.dispose();
+            imp.material.dispose();
+            imp.depth.dispose();
+            if (st.rtC) {
+                st.rtC.dispose();
+                st.rtN.dispose();
+            }
+            u.uImpReady.value = 0;
+        },
+    };
+}