@3driseai/3drise-viewer 0.1.42 → 0.1.43

package/dist/components/vegetation/core/grass.js

@@ -0,0 +1,102 @@
+// Emitted from Claude outputs/vegetation-lab/grass.mjs by gen_family.mjs — edit the lab module and re-emit.
+// Grass — vegetation object (lab module). Shared core: ./common.mjs (blades).
+// Construction: tens of thousands of bent blades over the footprint, seeded with a clump field
+// (tufts and bare patches), each with its own height, width, lean and curve. Wind: the shared gust
+// field bends every blade ∝ t² with a ripple travelling downwind, so waves run through the field;
+// the cursor parts it, puffs it or stirs it. Blades shade from a dark base to a lit tip, dry from the
+// tips with the season, and glow against the sun. Flowers (daisies / buttercups) and seed heads are
+// optional scattered layers. Size: the footprint is the transform's x/z, the box height the tallest blade.
+import * as THREE from 'three';
+import { mulberry32, setColor, createCommonUniforms, applyCommonConfig, updateCommon, QUALITY_V, LEAF_TYPES, bladeGeometry, setBlade, bladeMaterial, clumpedPositions, leafGeometry, setLeaf, unitBounds, leafMaterial, plantMesh, } from '../vegetationCore.js';
+const BLADE_BASE = 36000, FLOWER_BASE = 260;
+export function createUniforms() { return Object.assign(createCommonUniforms(), { uLeafType: { value: LEAF_TYPES.indexOf('blade') } }); }
+export function applyConfig(u, c, mats) {
+    applyCommonConfig(u, Object.assign({}, c, { leafType: undefined }));
+    if (c.bladeWidth !== undefined)
+        u.uLeafSize.value = c.bladeWidth;
+    if (!mats)
+        return;
+    if (c.flowerColor !== undefined)
+        setColor(mats.flowerU.uColor, c.flowerColor);
+}
+export function build(u, c) {
+    const q = QUALITY_V[c.quality] || 1;
+    const rnd = mulberry32((c.seed ?? 11) * 2654435761 + 23);
+    const n = Math.round(BLADE_BASE * (c.density ?? 1) * q);
+    const geo = bladeGeometry(n);
+    const pts = clumpedPositions(n, rnd, c.clumping ?? 0.5, 0.005);
+    // the clump field also sets height: tufts stand taller
+    for (let i = 0; i < n; i++) {
+        const p = pts[i];
+        const tuft = 0.5 + 0.5 * Math.sin(p.x * 17 + 2) * Math.cos(p.z * 13 - 1);
+        const h = (0.6 + 0.4 * rnd()) * (0.7 + 0.6 * tuft);
+        setBlade(geo, i, p, h, 0.011 * (0.7 + 0.6 * rnd()), rnd() * Math.PI * 2, rnd(), (c.lean ?? 0.7) * (0.15 + 1.2 * Math.pow(rnd(), 1.5)), rnd(), (i + 0.5) / n, 0);
+    }
+    for (const k of ['aPos', 'aInfoA', 'aInfoB'])
+        geo.attributes[k].needsUpdate = true;
+    // the height knob and growth both scale the blades: one uniform the blade shader reads as growth
+    const uG = Object.assign({}, u, { uGrowth: { value: (c.bladeHeight ?? 1) * (c.growth ?? 1) } });
+    const bladePair = bladeMaterial(uG, { translucency: 0.55 });
+    // meadow flowers: a stalk (blade), a petal fan and a centre disc, on a seeded subset of the positions
+    const nF = Math.round(FLOWER_BASE * (c.flowers ?? 0) * q * 2);
+    const flowerU = Object.assign({}, u, { uLeafType: { value: LEAF_TYPES.indexOf('petal') }, uColor: { value: new THREE.Color(c.flowerColor || '#f6f2e0') }, uShadeColor: { value: new THREE.Color('#b8ad8a') }, uGrowth: uG.uGrowth, uFoliage: { value: 1 }, uSeason: { value: 0 } });
+    const centreU = Object.assign({}, flowerU, { uLeafType: { value: LEAF_TYPES.indexOf('round') }, uColor: { value: new THREE.Color('#f2c230') }, uShadeColor: { value: new THREE.Color('#b88a10') } });
+    const petals = 7;
+    const fGeo = leafGeometry(Math.max(1, nF * petals)), cGeo = leafGeometry(Math.max(1, nF));
+    const stalks = bladeGeometry(Math.max(1, nF));
+    const along = new THREE.Vector3(), up = new THREE.Vector3(0, 1, 0), pos = new THREE.Vector3();
+    let fi = 0;
+    for (let i = 0; i < nF; i++) {
+        const p = pts[Math.floor(rnd() * pts.length)];
+        const h = 0.8 + 0.4 * rnd();
+        setBlade(stalks, i, p, h, 0.004, rnd() * Math.PI * 2, rnd(), 0.15 * rnd(), rnd(), 0, 0);
+        pos.set(p.x, h * 0.98, p.z);
+        const tilt = new THREE.Vector3(rnd() - 0.5, 1.5, rnd() - 0.5).normalize();
+        for (let k = 0; k < petals; k++) {
+            const a = k / petals * Math.PI * 2 + rnd() * 0.2;
+            along.set(Math.cos(a), 0.25, Math.sin(a)).normalize();
+            setLeaf(fGeo, fi++, pos, along, tilt, 0.0065, rnd(), h, 1, rnd(), 0.3, 0, 0);
+        }
+        setLeaf(cGeo, i, pos.clone().addScaledVector(tilt, 0.004), up.clone().addScaledVector(tilt, -up.dot(tilt)).normalize(), tilt, 0.0035, rnd(), h, 1, rnd(), 0.3, 0, 0);
+    }
+    fGeo.instanceCount = fi;
+    cGeo.instanceCount = nF;
+    for (const g of [fGeo, cGeo, stalks]) {
+        for (const k of ['aPos', 'aInfoA', 'aInfoB'])
+            g.attributes[k].needsUpdate = true;
+        if (g.attributes.aQuat)
+            g.attributes.aQuat.needsUpdate = true;
+        unitBounds(g);
+    }
+    const petalPair = leafMaterial(flowerU, { translucency: 0.7, veins: 0.0, roughness: 0.9, underside: 0.08 });
+    const centrePair = leafMaterial(centreU, { translucency: 0.2, veins: 0, roughness: 0.9, underside: 0 });
+    const stalkPair = bladeMaterial(uG, { translucency: 0.4 });
+    const object = new THREE.Group();
+    object.name = 'grass';
+    object.add(plantMesh(geo, bladePair, 'blades'), plantMesh(stalks, stalkPair, 'stalks'), plantMesh(fGeo, petalPair, 'petals'), plantMesh(cGeo, centrePair, 'centres'));
+    const state = { height: c.bladeHeight ?? 1, growth: c.growth ?? 1 };
+    const mats = { flowerU };
+    const applyAll = (cfg) => {
+        applyConfig(u, cfg, mats);
+        if (cfg.bladeHeight !== undefined)
+            state.height = cfg.bladeHeight;
+        if (cfg.growth !== undefined)
+            state.growth = cfg.growth;
+        uG.uGrowth.value = state.height * state.growth;
+    };
+    applyAll(c);
+    return {
+        object,
+        materials: [bladePair.material, stalkPair.material, petalPair.material, centrePair.material],
+        apply: applyAll,
+        update: function (dt, camera, sunWorld) { updateCommon(u, object, camera, dt, sunWorld); },
+        stats: { blades: n, flowers: nF },
+        dispose: function () { for (const g of [geo, stalks, fGeo, cGeo])
+            g.dispose(); for (const p of [bladePair, stalkPair, petalPair, centrePair]) {
+            p.material.dispose();
+            p.depth.dispose();
+        } },
+    };
+}
+/** Knobs whose change rebuilds the plant (dispose + build); every other knob is a live push through apply. */
+export const STRUCTURAL = ['clumping', 'density', 'quality', 'seed', 'flowers', 'lean'];

package/dist/components/vegetation/core/hedge.d.ts

@@ -0,0 +1,193 @@
+import * as THREE from 'three';
+export declare const SPECIES: {
+    boxwood: {
+        leaf: string;
+        size: number;
+        color: string;
+        shade: string;
+        autumn: string[];
+    };
+    privet: {
+        leaf: string;
+        size: number;
+        color: string;
+        shade: string;
+        autumn: string[];
+    };
+    yew: {
+        leaf: string;
+        size: number;
+        color: string;
+        shade: string;
+        autumn: string[];
+    };
+    laurel: {
+        leaf: string;
+        size: number;
+        color: string;
+        shade: string;
+        autumn: string[];
+    };
+    beech: {
+        leaf: string;
+        size: number;
+        color: string;
+        shade: string;
+        autumn: string[];
+    };
+    holly: {
+        leaf: string;
+        size: number;
+        color: string;
+        shade: string;
+        autumn: string[];
+    };
+    photinia: {
+        leaf: string;
+        size: number;
+        color: string;
+        shade: string;
+        autumn: string[];
+        redTips: number;
+    };
+    cypress: {
+        leaf: string;
+        size: number;
+        color: string;
+        shade: string;
+        autumn: string[];
+    };
+    hornbeam: {
+        leaf: string;
+        size: number;
+        color: string;
+        shade: string;
+        autumn: string[];
+    };
+    pittosporum: {
+        leaf: string;
+        size: number;
+        color: string;
+        shade: string;
+        autumn: string[];
+    };
+};
+export declare function createUniforms(): {
+    uTime: {
+        value: number;
+    };
+    uWindPhase: {
+        value: number;
+    };
+    uWindDir: {
+        value: THREE.Vector2;
+    };
+    uWindStrength: {
+        value: number;
+    };
+    uTurb: {
+        value: number;
+    };
+    uSpeed: {
+        value: number;
+    };
+    uSway: {
+        value: number;
+    };
+    uFlutter: {
+        value: number;
+    };
+    uScale: {
+        value: THREE.Vector3;
+    };
+    uMean: {
+        value: number;
+    };
+    uOpacity: {
+        value: number;
+    };
+    uColor: {
+        value: THREE.Color;
+    };
+    uShadeColor: {
+        value: THREE.Color;
+    };
+    uSeason: {
+        value: number;
+    };
+    uFoliage: {
+        value: number;
+    };
+    uLeafType: {
+        value: number;
+    };
+    uLeafSize: {
+        value: number;
+    };
+    uGrowth: {
+        value: number;
+    };
+    uSunDirView: {
+        value: THREE.Vector3;
+    };
+    uViewPos: {
+        value: THREE.Vector3;
+    };
+    uLodK: {
+        value: number;
+    };
+    uLodOrtho: {
+        value: number;
+    };
+    uLodBias: {
+        value: number;
+    };
+    uImpReady: {
+        value: number;
+    };
+    uBake: {
+        value: number;
+    };
+    uBakeView: {
+        value: THREE.Matrix3;
+    };
+    uBakeDepth: {
+        value: THREE.Vector2;
+    };
+};
+export declare function applyConfig(u: any, c: any, mats: any): void;
+export declare function speciesColors(c: any): any;
+export declare function build(u: any, c: any): {
+    object: THREE.Group<THREE.Object3DEventMap>;
+    materials: any[];
+    apply: (cfg: any) => void;
+    update: (dt: any, camera: any, sunWorld: any, renderer: any) => void;
+    lod: {
+        impostor: THREE.Mesh<any, any, THREE.Object3DEventMap>;
+        state: {
+            u: any;
+            ready: boolean;
+            wanted: boolean;
+            dirty: boolean;
+            changedAt: number;
+            lastBake: number;
+            t: number;
+            frame: number;
+            key: string;
+            bakeScale: THREE.Vector3;
+            rtC: any;
+            rtN: any;
+        };
+        update(dt: any, renderer: any): void;
+        applied(cfg: any): void;
+        dispose(): void;
+    };
+    stats: {
+        leaves: number;
+        twigs: number;
+    };
+    dispose: () => void;
+};
+/** Knobs whose change rebuilds the plant (dispose + build); every other knob is a live push through apply. */
+export declare const STRUCTURAL: string[];
+//# sourceMappingURL=hedge.d.ts.map

package/dist/components/vegetation/core/hedge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hedge.d.ts","sourceRoot":"","sources":["../../../../src/components/vegetation/core/hedge.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAO/B,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAWnB,CAAC;AAuCF,wBAAgB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAqC;AAEnE,wBAAgB,WAAW,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA,EAAE,IAAI,KAAA,QAOrC;AAED,wBAAgB,aAAa,CAAC,CAAC,KAAA,OAO9B;AAED,wBAAgB,KAAK,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8EzB;AAED,8GAA8G;AAC9G,eAAO,MAAM,UAAU,UAAqD,CAAC"}

package/dist/components/vegetation/core/hedge.js

@@ -0,0 +1,243 @@
+// Emitted from Claude outputs/vegetation-lab/hedge.mjs by gen_family.mjs — edit the lab module and re-emit.
+// vegetation/core/hedge — Hedge (type 'vegetation', config.type 'hedge'). Shared core: ../vegetationCore.
+// Construction: a clipped shape (box, dome, ball, cylinder, cone, spiral topiary) filled with
+// foliage: leaf cards sampled on the shape's surface with normals facing out (the clipped skin, dense,
+// small leaves), a sparser fill inside (so gaps show depth, not emptiness), and a lattice of twigs
+// (short stubs) under the skin. `trim` is how recently it was clipped: 0 = razor flat, 1 = shaggy
+// (the skin's cards scatter outward and tilt). Lit by depth: skin bright, inside shaded. Wind: a
+// soft shimmer only. Size: the box is the clipped shape's bounding box.
+import * as THREE from 'three';
+import { mulberry32, setColor, createCommonUniforms, applyCommonConfig, updateCommon, QUALITY_V, LEAF_TYPES, branchGeometry, leafGeometry, setLeaf, unitBounds, barkMaterial, leafMaterial, plantMesh, plantLod, } from '../vegetationCore.js';
+export const SPECIES = {
+    boxwood: { leaf: 'round', size: 0.022, color: '#3f7f2e', shade: '#15301a', autumn: ['#7a8a2a', '#5a6a1a'] },
+    privet: { leaf: 'broadleaf', size: 0.024, color: '#4f8f36', shade: '#1e3a1a', autumn: ['#b89a2a', '#7a5a1a'] },
+    yew: { leaf: 'needles', size: 0.022, color: '#2f5a2a', shade: '#102414', autumn: ['#4a5a2a', '#3a4a1a'] },
+    laurel: { leaf: 'broadleaf', size: 0.04, color: '#3a7a30', shade: '#14301a', autumn: ['#8a8a2a', '#5a5a1a'] },
+    beech: { leaf: 'broadleaf', size: 0.028, color: '#6a9a3a', shade: '#2a4a1a', autumn: ['#c88a2a', '#8a4a1a'] },
+    holly: { leaf: 'lobed', size: 0.026, color: '#2a5a2a', shade: '#0f2414', autumn: ['#3a5a2a', '#2a4a1a'] },
+    photinia: { leaf: 'broadleaf', size: 0.03, color: '#4a7a3a', shade: '#1e3a1a', autumn: ['#c8302a', '#8a1a1a'], redTips: 0.35 },
+    cypress: { leaf: 'needles', size: 0.02, color: '#3a6a3a', shade: '#14301a', autumn: ['#4a5a2a', '#3a4a1a'] },
+    hornbeam: { leaf: 'broadleaf', size: 0.022, color: '#5f9a3a', shade: '#2a4a1a', autumn: ['#d8a83a', '#8a5a2a'] },
+    pittosporum: { leaf: 'round', size: 0.022, color: '#8fb86a', shade: '#3a5a2a', autumn: ['#9a9a4a', '#6a6a3a'] },
+};
+const SKIN_BASE = 30000, FILL_BASE = 5000, TWIG_BASE = 700;
+/** Signed distance and normal of the clipped shape in the unit box (x/z ±0.5, y 0..1). */
+function shapeSdf(shape, p, out) {
+    const x = p.x, y = p.y - 0.5, z = p.z;
+    let d, n = out;
+    if (shape === 'ball') {
+        const r = Math.hypot(x, y, z);
+        d = r - 0.5;
+        n.set(x, y, z).divideScalar(Math.max(r, 1e-6));
+    }
+    else if (shape === 'dome') {
+        const r = Math.hypot(x, p.y, z);
+        d = Math.max(r - 0.5 * Math.SQRT2 * 0.72, -p.y);
+        n.set(x, p.y, z).normalize();
+        if (-p.y > r - 0.5)
+            n.set(0, -1, 0);
+    }
+    else if (shape === 'cylinder') {
+        const r = Math.hypot(x, z);
+        const dr = r - 0.5, dy = Math.abs(y) - 0.5;
+        d = Math.max(dr, dy);
+        if (dr > dy)
+            n.set(x, 0, z).normalize();
+        else
+            n.set(0, Math.sign(y) || 1, 0);
+    }
+    else if (shape === 'cone') {
+        const r = Math.hypot(x, z);
+        const rr = 0.5 * (1 - p.y);
+        const dr = (r - rr) * 0.894;
+        const dy = Math.max(-p.y, p.y - 1);
+        d = Math.max(dr, dy);
+        if (dr > dy)
+            n.set(x, r * 0.5, z).normalize();
+        else
+            n.set(0, p.y > 0.5 ? 1 : -1, 0);
+    }
+    else if (shape === 'spiral') {
+        // a cone wound with a spiral groove: the classic topiary
+        const r = Math.hypot(x, z);
+        const a = Math.atan2(z, x);
+        const rr = 0.5 * (1 - p.y * 0.85);
+        const groove = 0.5 + 0.5 * Math.cos(a - p.y * 14);
+        const dr = (r - rr * (0.55 + 0.45 * groove)) * 0.85;
+        const dy = Math.max(-p.y, p.y - 1);
+        d = Math.max(dr, dy);
+        if (dr > dy)
+            n.set(x, r * 0.4, z).normalize();
+        else
+            n.set(0, p.y > 0.5 ? 1 : -1, 0);
+    }
+    else if (shape === 'pyramid') {
+        const r = Math.max(Math.abs(x), Math.abs(z));
+        const rr = 0.5 * (1 - p.y);
+        d = Math.max((r - rr) * 0.9, Math.max(-p.y, p.y - 1));
+        n.set(Math.abs(x) > Math.abs(z) ? Math.sign(x) : 0, 0.45, Math.abs(z) >= Math.abs(x) ? Math.sign(z) : 0).normalize();
+        if (p.y > 0.98)
+            n.set(0, 1, 0);
+    }
+    else if (shape === 'obelisk') {
+        const r = Math.max(Math.abs(x), Math.abs(z));
+        const rr = 0.5 * (1 - 0.55 * p.y) * (p.y > 0.9 ? (1 - p.y) * 10 : 1);
+        d = Math.max(r - rr, Math.max(-p.y, p.y - 1));
+        n.set(Math.abs(x) > Math.abs(z) ? Math.sign(x) : 0, 0.25, Math.abs(z) >= Math.abs(x) ? Math.sign(z) : 0).normalize();
+    }
+    else if (shape === 'arch') { // a box with a tunnel through it (along z)
+        const q = new THREE.Vector3(Math.abs(x) - 0.46, Math.abs(y) - 0.46, Math.abs(z) - 0.46);
+        const o = new THREE.Vector3(Math.max(q.x, 0), Math.max(q.y, 0), Math.max(q.z, 0));
+        const box = o.length() + Math.min(Math.max(q.x, q.y, q.z), 0) - 0.04;
+        const tun = -(Math.hypot(x * 1.6, Math.max(0, p.y - 0.3) * 1.3) - 0.42); // round-topped opening
+        d = Math.max(box, tun);
+        if (tun > box)
+            n.set(-x * 1.6, -Math.max(0, p.y - 0.3) * 1.3, 0).normalize();
+        else if (o.lengthSq() > 1e-8)
+            n.set(o.x * Math.sign(x), o.y * Math.sign(y), o.z * Math.sign(z)).normalize();
+        else {
+            if (q.x > q.y && q.x > q.z)
+                n.set(Math.sign(x), 0, 0);
+            else if (q.y > q.z)
+                n.set(0, Math.sign(y), 0);
+            else
+                n.set(0, 0, Math.sign(z));
+        }
+        if (p.y < 0.02) {
+            n.set(0, -1, 0);
+        }
+    }
+    else { // box with rounded edges
+        const q = new THREE.Vector3(Math.abs(x) - 0.46, Math.abs(y) - 0.46, Math.abs(z) - 0.46);
+        const o = new THREE.Vector3(Math.max(q.x, 0), Math.max(q.y, 0), Math.max(q.z, 0));
+        d = o.length() + Math.min(Math.max(q.x, q.y, q.z), 0) - 0.04;
+        if (o.lengthSq() > 1e-8)
+            n.set(o.x * Math.sign(x), o.y * Math.sign(y), o.z * Math.sign(z)).normalize();
+        else {
+            if (q.x > q.y && q.x > q.z)
+                n.set(Math.sign(x), 0, 0);
+            else if (q.y > q.z)
+                n.set(0, Math.sign(y), 0);
+            else
+                n.set(0, 0, Math.sign(z));
+        }
+    }
+    return d;
+}
+export function createUniforms() { return createCommonUniforms(); }
+export function applyConfig(u, c, mats) {
+    if (c.species !== undefined)
+        c = Object.assign({}, c, speciesColors(c));
+    applyCommonConfig(u, Object.assign({}, c, { leafType: undefined }));
+    if (c.species !== undefined)
+        u.uLeafType.value = Math.max(0, LEAF_TYPES.indexOf((SPECIES[c.species] || SPECIES.boxwood).leaf));
+    if (!mats)
+        return;
+    if (c.barkColor !== undefined)
+        setColor(mats.bark.userData.uniforms.uBarkColor, c.barkColor);
+    if (c.trim !== undefined)
+        mats.trim.value = c.trim;
+}
+export function speciesColors(c) {
+    const sp = SPECIES[c.species] || SPECIES.boxwood;
+    const all = Object.values(SPECIES);
+    const out = Object.create(null); // only the keys set below override the config
+    if (!c.color || c.color.toLowerCase() === '#3f7f2e' || all.some((s) => s.color.toLowerCase() === c.color.toLowerCase()))
+        out.color = sp.color;
+    if (!c.shadeColor || c.shadeColor.toLowerCase() === '#15301a' || all.some((s) => s.shade.toLowerCase() === c.shadeColor.toLowerCase()))
+        out.shadeColor = sp.shade;
+    return out;
+}
+export function build(u, c) {
+    const q = QUALITY_V[c.quality] || 1;
+    const sp = SPECIES[c.species] || SPECIES.boxwood;
+    c = Object.assign({}, c, speciesColors(c));
+    const rnd = mulberry32((c.seed ?? 17) * 2654435761 + 171);
+    const shape = c.shape || 'box';
+    const nSkin = Math.round(SKIN_BASE * (c.density ?? 1) * q), nFill = Math.round(FILL_BASE * (c.density ?? 1) * q);
+    const geo = leafGeometry(nSkin + nFill);
+    const p = new THREE.Vector3(), n = new THREE.Vector3(), along = new THREE.Vector3(), nrm = new THREE.Vector3(), tmp = new THREE.Vector3();
+    let i = 0, tries = 0;
+    // skin: rejection-sample points near the surface (|sdf| small), project onto it, face outward
+    while (i < nSkin && tries++ < nSkin * 40) {
+        p.set(rnd() - 0.5, rnd(), rnd() - 0.5);
+        const d = shapeSdf(shape, p, n);
+        if (Math.abs(d) > 0.06)
+            continue;
+        p.addScaledVector(n, -d);
+        if (p.y < 0.01)
+            continue;
+        nrm.copy(n).add(tmp.set(rnd() - 0.5, rnd() - 0.5, rnd() - 0.5).multiplyScalar(0.7)).normalize();
+        along.crossVectors(nrm, tmp.set(rnd() - 0.5, rnd() - 0.5, rnd() - 0.5)).normalize().addScaledVector(nrm, 0.35).normalize();
+        // the trim: aInfoB.w (the grow slot is free here) carries how far this card may stand proud of the skin
+        setLeaf(geo, i, p, along, nrm, sp.size * (0.8 + 0.4 * rnd()), rnd(), p.y, 0.85 + 0.15 * rnd(), rnd(), 0.15, rnd() * 0.5, 0);
+        geo.attributes.aInfoB.setW(i, 0);
+        // shaggy growth: a seeded outward offset the shader scales by uTrim (stored in aRoot as a direction × amount)
+        geo.attributes.aRoot.setXYZ(i, n.x * rnd() * 0.06, n.y * rnd() * 0.06, n.z * rnd() * 0.06);
+        i++;
+    }
+    // fill: inside, facing anywhere, shaded by depth
+    tries = 0;
+    while (i < nSkin + nFill && tries++ < nFill * 40) {
+        p.set(rnd() - 0.5, rnd(), rnd() - 0.5);
+        const d = shapeSdf(shape, p, n);
+        if (d > -0.03 || p.y < 0.01)
+            continue;
+        nrm.set(rnd() - 0.5, rnd() - 0.5, rnd() - 0.5).normalize();
+        along.crossVectors(nrm, tmp.set(rnd() - 0.5, rnd() - 0.5, rnd() - 0.5)).normalize();
+        setLeaf(geo, i, p, along, nrm, sp.size * (0.8 + 0.4 * rnd()), rnd(), p.y, Math.max(0, 0.6 + d * 4), rnd(), 0.1, 0.5 + rnd() * 0.5, 0);
+        geo.attributes.aRoot.setXYZ(i, 0, 0, 0);
+        i++;
+    }
+    geo.instanceCount = i;
+    for (const k of ['aPos', 'aRoot', 'aQuat', 'aInfoA', 'aInfoB'])
+        geo.attributes[k].needsUpdate = true;
+    unitBounds(geo);
+    // twigs: short stubs just under the skin, pointing out
+    const twigs = [];
+    tries = 0;
+    const nT = Math.round(TWIG_BASE * q);
+    while (twigs.length < nT && tries++ < nT * 40) {
+        p.set(rnd() - 0.5, rnd(), rnd() - 0.5);
+        const d = shapeSdf(shape, p, n);
+        if (d > -0.02 || d < -0.12 || p.y < 0.02)
+            continue;
+        const a = p.clone().addScaledVector(n, -0.08 - rnd() * 0.1), b = p.clone().addScaledVector(n, 0.015 + rnd() * 0.02);
+        const m = a.clone().lerp(b, 0.5).add(tmp.set(rnd() - 0.5, rnd() - 0.5, rnd() - 0.5).multiplyScalar(0.03));
+        twigs.push({ level: 1, pts: [a, m, b], radii: [0.004, 0.003, 0.0015], hf0: a.y, phase: rnd(), flex: 0.05 });
+    }
+    const barkPair = barkMaterial(u, { barkColor: c.barkColor || '#5a4a38', ridges: 0.3, lod: true });
+    const leafPair = leafMaterial(u, { translucency: 0.35, veins: 0.3, autumnA: sp.autumn[0], autumnB: sp.autumn[1], lod: true });
+    // the trim knob: the leaf shader's root slot is (ab)used as an outward growth vector scaled by uTrim
+    const trimU = { value: c.trim ?? 0.25 };
+    const wrap = (mat) => { const orig = mat.onBeforeCompile; mat.onBeforeCompile = (shader) => { orig(shader); shader.uniforms.uTrim = trimU; shader.vertexShader = shader.vertexShader.replace('attribute vec3 aRoot;', 'attribute vec3 aRoot; uniform float uTrim;').replace('vec3 ap = aRoot + (aPos - aRoot) * uGrowth;', 'vec3 ap = aPos + aRoot * uTrim * 1.5;'); }; };
+    wrap(leafPair.material);
+    wrap(leafPair.depth);
+    leafPair.material.customProgramCacheKey = () => 'veg-leaf-hedge-lod';
+    leafPair.depth.customProgramCacheKey = () => 'veg-leaf-hedge-lod-depth';
+    const twigGeo = branchGeometry(twigs, { sides: [4, 4, 3] });
+    unitBounds(twigGeo);
+    const object = new THREE.Group();
+    object.name = 'hedge';
+    const twigsM = plantMesh(twigGeo, barkPair, 'twigs'), leavesM = plantMesh(geo, leafPair, 'leaves');
+    object.add(twigsM, leavesM);
+    // the skin cards come first, the inner fill after: thinning at distance drops the hidden fill first
+    const lod = plantLod(u, object, { leaves: [leavesM], bark: [twigsM], bake: [twigsM, leavesM] });
+    const mats = { bark: barkPair.material, trim: trimU };
+    applyConfig(u, c, mats);
+    lod.applied(c);
+    return {
+        object,
+        materials: [barkPair.material, leafPair.material, lod.impostor.material],
+        apply: function (cfg) { applyConfig(u, cfg, mats); lod.applied(cfg); },
+        update: function (dt, camera, sunWorld, renderer) { updateCommon(u, object, camera, dt, sunWorld); lod.update(dt, renderer); },
+        lod,
+        stats: { leaves: i, twigs: twigs.length },
+        dispose: function () { geo.dispose(); twigGeo.dispose(); lod.dispose(); for (const pr of [barkPair, leafPair]) {
+            pr.material.dispose();
+            pr.depth.dispose();
+        } },
+    };
+}
+/** Knobs whose change rebuilds the plant (dispose + build); every other knob is a live push through apply. */
+export const STRUCTURAL = ['shape', 'species', 'density', 'quality', 'seed'];