@3driseai/3drise-viewer 0.1.42 → 0.1.43

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

@@ -0,0 +1,310 @@
+// Emitted from Claude outputs/vegetation-lab/forest.mjs by gen_family.mjs — edit the lab module and re-emit.
+// Forest — vegetation object (lab module). Shared core: ./common.mjs; plants: ./tree.mjs, ./bush.mjs.
+// Built for hundreds to thousands of trees:
+//   plants     one plant per species in the mix (trees) plus the undergrowth bushes, each built ONCE by the
+//              tree / bush generator and never drawn itself. Each bakes its octahedral impostor
+//              (common.mjs "detail levels") — one bake at a time, so loading a forest is not one long hitch.
+//   the stand  every tree of a species is one instance of that species' impostor card in ONE GPU-instanced
+//              draw (one more for its shadow): a thousand oaks are two draw calls and ~2,000 triangles.
+//   near       a fixed budget of the trees nearest to the camera (nearTrees) is drawn as real plants:
+//              copies of the plant's meshes (shared geometry / materials) moved onto those trees every
+//              frame. A tree drawn in full flags its instance (aImpSlot) so its card cross-fades out with
+//              the dither the plant's leaves fade in with; every other tree stays the card.
+//   placement  a jittered grid over the floor of the box, thinned by a low-frequency noise mask into groves
+//              and glades (clumping) — linear in the number of trees. Species drawn by the mix's weights.
+//   size       the box: x/z is the forest floor, y the canopy height. Heights follow the box (taller species
+//              reach the top), crown widths follow each species' form in metres, so a stretched box never
+//              stretches the trees. Undergrowth is 5–12.5 % of the canopy height (1–2.5 m at
+//              the default 20 m box), so scaling the forest or its parents scales the whole stand.
+//   wind       one field: gust fronts travel across the stand (gustAt reads each instance's position).
+import * as THREE from 'three';
+import { createCommonUniforms, applyCommonConfig, mulberry32, LOD } from '../vegetationCore.js';
+import * as TREE from './tree.js';
+import * as BUSH from './bush.js';
+const DEFAULT_COLOR = '#4f8a3a', DEFAULT_SHADE = '#1f3d1a';
+// ----------------------------------------------------------------------------- mixes
+// trees: [species, weight]; under: undergrowth bush species. FORM: crown width / height and height as a
+// share of the canopy, per tree species, from their silhouettes.
+export const MIXES = {
+    temperate: { trees: [['oak', 3], ['maple', 2], ['birch', 1.5]], under: ['wildShrub', 'fern'] },
+    conifer: { trees: [['pine', 3], ['spruce', 3], ['birch', 0.5]], under: ['juniper', 'fern'] },
+    birch: { trees: [['birch', 4], ['poplar', 1]], under: ['fern', 'wildShrub'] },
+    autumn: { trees: [['maple', 3], ['oak', 2], ['birch', 1]], under: ['wildShrub', 'heather'] },
+    mediterranean: { trees: [['olive', 3], ['cypress', 2]], under: ['rosemary', 'lavender'] },
+    tropical: { trees: [['palm', 3], ['eucalyptus', 1], ['jacaranda', 1]], under: ['fern', 'hibiscus'] },
+    savanna: { trees: [['acacia', 4], ['baobab', 0.5]], under: ['agave'] },
+    blossom: { trees: [['cherryBlossom', 2], ['magnolia', 1], ['jacaranda', 1]], under: ['azalea', 'camellia'] },
+    winter: { trees: [['bare', 3], ['spruce', 1.5]], under: ['heather'] },
+};
+const FORM = {
+    oak: [0.9, 0.85], maple: [0.85, 0.8], birch: [0.55, 0.85], pine: [0.5, 0.95], spruce: [0.45, 1], poplar: [0.3, 1],
+    olive: [1.0, 0.5], cypress: [0.25, 1], palm: [0.7, 0.9], eucalyptus: [0.6, 1], jacaranda: [1.0, 0.7],
+    cherryBlossom: [0.95, 0.55], magnolia: [0.8, 0.55], acacia: [1.4, 0.55], baobab: [0.9, 0.7], willow: [1.0, 0.7], bare: [0.8, 0.85],
+};
+// undergrowth as fractions of the canopy height (the box height), so the whole stand scales together:
+// at the default 20 m box that is a 2.2 x 1.6 m bush base, items 1.0 - 2.5 m tall
+const BUSH_W = 0.11, BUSH_H = 0.08, UNDER_H = [0.05, 0.125];
+export function createUniforms() { return createCommonUniforms(); }
+/** The knobs each plant receives: the forest's live knobs; colours only when moved off the forest default (else each species keeps its own). */
+function plantCfg(c, base) {
+    const p = Object.assign(Object.create(null), base); // any knob may be added below
+    for (const k of ['quality', 'leafSize', 'foliage', 'seasonHue', 'leafFall', 'flutter', 'sway', 'opacity', 'speed', 'windStrength', 'windDirection', 'turbulence'])
+        if (c[k] !== undefined)
+            p[k] = c[k];
+    if (c.color && c.color.toLowerCase() !== DEFAULT_COLOR)
+        p.color = c.color;
+    if (c.shadeColor && c.shadeColor.toLowerCase() !== DEFAULT_SHADE)
+        p.shadeColor = c.shadeColor;
+    return p;
+}
+function treeBase(species, seed) {
+    const sp = TREE.SPECIES[species] || TREE.SPECIES.oak;
+    return {
+        type: 'tree', species, trunkRatio: 1, branchiness: 1, droop: 0, twist: 0.5, density: 0.4, seed, lod: 'auto',
+        leafType: 'auto', flowers: sp['flowersAlways'] || 0, flowerColor: '#ffffff', fruit: 'none', fruitAmount: 0.5, ripeness: 1, fruitColor: '#ffffff',
+    };
+}
+function bushBase(species, seed) {
+    return { type: 'bush', species, spread: 1, twist: 0.5, density: 0.8, seed, lod: 'auto', leafType: 'auto', flowers: 0, flowerColor: '#ffffff', fruit: 'none', fruitAmount: 0.5, ripeness: 1, fruitColor: '#ffffff' };
+}
+export function applyConfig(u, c, plants) {
+    applyCommonConfig(u, c);
+    if (!plants)
+        return;
+    for (const p of plants)
+        p.inst.apply(plantCfg(c, p.base));
+}
+/** A smooth value-noise field on the floor (groves / glades), deterministic per seed. */
+function noiseField(seed) {
+    const h = (x, y) => { let n = Math.imul(x, 374761393) + Math.imul(y, 668265263) + Math.imul(seed, 2147483647); n = Math.imul(n ^ (n >>> 13), 1274126177); return ((n ^ (n >>> 16)) >>> 0) / 4294967296; };
+    const sm = (t) => t * t * (3 - 2 * t);
+    const v = (x, y) => { const xi = Math.floor(x), yi = Math.floor(y), fx = sm(x - xi), fy = sm(y - yi); return (h(xi, yi) * (1 - fx) + h(xi + 1, yi) * fx) * (1 - fy) + (h(xi, yi + 1) * (1 - fx) + h(xi + 1, yi + 1) * fx) * fy; };
+    return (x, y) => 0.65 * v(x, y) + 0.35 * v(x * 2.3 + 7.1, y * 2.3 + 3.7);
+}
+export function build(u, c) {
+    const mix = MIXES[c.mix] || MIXES.temperate;
+    const seed = c.seed ?? 9;
+    const rnd = mulberry32(seed * 2654435761 + 313);
+    const object = new THREE.Group();
+    object.name = 'forest';
+    // the stand lives in metres: this group cancels the box scale (set from the world scale)
+    const metres = new THREE.Group();
+    object.add(metres);
+    // ---- the plants: one per species, never drawn themselves
+    const plants = [];
+    const addPlant = (M, base, kind) => {
+        const pu = M.createUniforms();
+        const cfg = plantCfg(c, base);
+        const inst = M.build(pu, cfg);
+        inst.apply(cfg);
+        const holder = new THREE.Group(); // the plant at its species' base size (metres)
+        holder.add(inst.object);
+        metres.add(holder);
+        const parts = [];
+        inst.object.traverse((o) => { if (o.isMesh)
+            parts.push(o); });
+        for (const p of parts)
+            p.layers.disableAll();
+        const imp = inst.lod.impostor;
+        const plant = { inst, base, kind, holder, u: pu, parts: parts.filter((p) => p !== imp), imp, size: [1, 1], items: [], cards: null, slots: [], slotOf: [] };
+        plants.push(plant);
+        return plant;
+    };
+    const treePlants = mix.trees.map(([sp], k) => addPlant(TREE, treeBase(sp, seed + k * 17), 'tree'));
+    const nTrees = Math.max(1, Math.round(c.trees ?? 800));
+    const nUnder = Math.round(nTrees * (c.undergrowth ?? 0.3));
+    const underPlants = nUnder > 0 ? mix.under.map((sp, k) => addPlant(BUSH, bushBase(sp, seed + 101 + k * 13), 'bush')) : [];
+    // ---- placement: a jittered grid on the unit floor, thinned by a noise mask into groves and glades
+    const field = noiseField(seed);
+    const clump = c.clumping ?? 0.4;
+    const scatter = (n, sp, salt) => {
+        const keepRate = 1 - 0.6 * clump;
+        const side = Math.max(1, Math.ceil(Math.sqrt(n / keepRate) * 1.15));
+        const out = [];
+        for (let j = 0; j < side; j++)
+            for (let i = 0; i < side; i++) {
+                const x = ((i + 0.15 + 0.7 * rnd()) / side - 0.5) * 0.96, z = ((j + 0.15 + 0.7 * rnd()) / side - 0.5) * 0.96;
+                const v = field(x * 4 + salt, z * 4 - salt);
+                // glades where the noise is low: clumping 0.6+ empties them, lower values only thin them
+                let keep = Math.max(0, 1 - clump * 1.7 * (1 - Math.min(1, Math.max(0, (v - 0.38) / 0.22))));
+                // a natural outline instead of the box's square edge: a rounded square (superellipse) warped by
+                // noise, the stand thinning across a band of varying width
+                const r = Math.cbrt(Math.abs(x) ** 3 + Math.abs(z) ** 3) / 0.48;
+                const warp = (field(x * 3 - salt, z * 3 + 11.3) - 0.5) * 0.4;
+                const band = 0.05 + 0.12 * field(x * 7 + 5.1, z * 7 - salt);
+                keep *= Math.min(1, Math.max(0, (1 - r + warp) / band));
+                if (rnd() < keep)
+                    out.push({ x, z });
+            }
+        for (let i = out.length - 1; i > 0; i--) {
+            const k = Math.floor(rnd() * (i + 1));
+            const t = out[i];
+            out[i] = out[k];
+            out[k] = t;
+        }
+        return out.slice(0, n);
+    };
+    const totalW = mix.trees.reduce((s, t) => s + t[1], 0);
+    for (const p of scatter(nTrees, null, 0)) {
+        let w = rnd() * totalW, k = 0;
+        while (k < mix.trees.length - 1 && (w -= mix.trees[k][1]) > 0)
+            k++;
+        treePlants[k].items.push({ x: p.x, z: p.z, yaw: rnd() * 6.2832, h: 1 - (c.sizeVar ?? 0.3) * rnd() });
+    }
+    if (underPlants.length)
+        for (const p of scatter(nUnder, null, 3.3))
+            underPlants[Math.floor(rnd() * underPlants.length)].items.push({ x: p.x, z: p.z, yaw: rnd() * 6.2832, h: rnd() });
+    // ---- per plant: one instanced draw of its impostor card for all its items, and the near slots
+    const nearBudget = Math.max(0, Math.round(c.nearTrees ?? 24));
+    for (const pl of plants) {
+        const n = Math.max(1, pl.items.length);
+        const cards = new THREE.InstancedMesh(pl.imp.geometry, pl.imp.material, n);
+        cards.customDepthMaterial = pl.imp.customDepthMaterial;
+        cards.castShadow = true;
+        cards.receiveShadow = false;
+        cards.frustumCulled = false; // one draw for the whole stand
+        cards.raycast = function () { };
+        cards.name = 'forest:cards';
+        cards.count = pl.items.length;
+        const slotAttr = new THREE.InstancedBufferAttribute(new Float32Array(n), 1);
+        slotAttr.setUsage(THREE.DynamicDrawUsage);
+        cards.geometry = pl.imp.geometry.clone(); // its own geometry: the slot flags are per stand
+        cards.geometry.setAttribute('aImpSlot', slotAttr);
+        cards.geometry.boundingSphere = pl.imp.geometry.boundingSphere;
+        metres.add(cards);
+        pl.cards = cards;
+        pl.slotAttr = slotAttr;
+        // near slots: copies of the plant's meshes, moved onto the nearest trees each frame
+        const nSlots = Math.min(pl.items.length, pl.kind === 'tree' ? nearBudget : Math.round(nearBudget / 2));
+        for (let s = 0; s < nSlots; s++) {
+            const copies = pl.parts.map((src) => {
+                const m = new THREE.Mesh(src.geometry, src.material);
+                m.customDepthMaterial = src.customDepthMaterial;
+                m.castShadow = src.castShadow;
+                m.receiveShadow = src.receiveShadow;
+                m.frustumCulled = src.frustumCulled;
+                m.raycast = src.raycast;
+                m.matrixAutoUpdate = false;
+                m.visible = false;
+                m.name = 'forest:near';
+                if (src.userData.mirrorSetup)
+                    src.userData.mirrorSetup(m);
+                metres.add(m);
+                return { m, src };
+            });
+            pl.slots.push({ copies, item: -1 });
+        }
+    }
+    // ---- sizes follow the box: laid out again when the world scale changes
+    const F = new THREE.Vector3(), lastF = new THREE.Vector3(-1, -1, -1);
+    const _m = new THREE.Matrix4(), _q = new THREE.Quaternion(), _p = new THREE.Vector3(), _s = new THREE.Vector3(), _y = new THREE.Vector3(0, 1, 0);
+    function layout() {
+        metres.scale.set(1 / F.x, 1 / F.y, 1 / F.z);
+        const maxW = Math.min(F.x, F.z) * 0.45;
+        for (const pl of plants) {
+            if (pl.kind === 'tree') {
+                const form = FORM[pl.base.species] || [0.8, 0.85];
+                const h = F.y * form[1], w = Math.min(maxW, h * form[0]);
+                pl.size = [w, h];
+            }
+            else
+                pl.size = [Math.min(maxW, F.y * BUSH_W), F.y * BUSH_H];
+            pl.holder.scale.set(pl.size[0], pl.size[1], pl.size[0]);
+            pl.items.forEach((it, i) => {
+                const k = pl.kind === 'tree' ? it.h : (UNDER_H[0] + (UNDER_H[1] - UNDER_H[0]) * it.h) / BUSH_H; // fractions of F.y, ratio is scale-free
+                it.r = 0.5 * Math.hypot(pl.size[0] * k, pl.size[1] * k, pl.size[0] * k); // bounding radius (m)
+                it.lx = it.x * F.x;
+                it.lz = it.z * F.z;
+                it.ly = 0.5 * pl.size[1] * k; // centre, in the stand's metres
+                it.mat = _m.compose(_p.set(it.lx, 0, it.lz), _q.setFromAxisAngle(_y, it.yaw), _s.set(pl.size[0] * k, pl.size[1] * k, pl.size[0] * k)).clone();
+                pl.cards.setMatrixAt(i, it.mat);
+            });
+            pl.cards.instanceMatrix.needsUpdate = true;
+            pl.cards.boundingSphere = null;
+            pl.cards.boundingBox = null;
+            for (const sl of pl.slots)
+                sl.item = -1;
+        }
+        lastF.copy(F);
+    }
+    // ---- per frame: which trees are near enough for full detail (by the same screen size the detail levels use)
+    const _inv = new THREE.Matrix4(), _cam = new THREE.Vector3();
+    function chooseNear() {
+        for (const pl of plants) {
+            if (!pl.slots.length)
+                continue;
+            const pu = pl.u;
+            const lodK = pu.uLodK.value, ortho = pu.uLodOrtho.value > 0.5;
+            // the camera in the stand's metres (the stand has no scale of its own: metres cancels the box)
+            _inv.copy(metres.matrixWorld).invert();
+            _cam.copy(pu.uViewPos.value).applyMatrix4(_inv);
+            const cand = [];
+            const minS = LOD.IMP * LOD.FADE_OUT;
+            pl.items.forEach((it, i) => {
+                const d = ortho ? 1 : Math.max(1e-3, Math.hypot(it.lx - _cam.x, it.ly - _cam.y, it.lz - _cam.z));
+                const s = it.r * lodK / d;
+                if (s > minS)
+                    cand.push([s, i]);
+            });
+            cand.sort((a, b) => b[0] - a[0]);
+            const want = new Set(cand.slice(0, pl.slots.length).map((x) => x[1]));
+            const flags = pl.slotAttr.array;
+            // keep slots on trees that stay near; free the rest; give free slots to the newcomers
+            const free = [];
+            for (const sl of pl.slots) {
+                if (sl.item >= 0 && want.has(sl.item))
+                    want.delete(sl.item);
+                else {
+                    if (sl.item >= 0)
+                        flags[sl.item] = 0;
+                    sl.item = -1;
+                    free.push(sl);
+                }
+            }
+            for (const i of want) {
+                const sl = free.pop();
+                if (!sl)
+                    break;
+                sl.item = i;
+                flags[i] = 1;
+                for (const { m } of sl.copies) {
+                    m.matrix.copy(pl.items[i].mat);
+                    m.matrixWorldNeedsUpdate = true;
+                }
+            }
+            for (const sl of pl.slots)
+                for (const { m, src } of sl.copies)
+                    m.visible = sl.item >= 0 && src.visible;
+            pl.slotAttr.needsUpdate = true;
+        }
+    }
+    applyConfig(u, c, plants);
+    return {
+        object,
+        materials: [],
+        apply: function (cfg) { applyConfig(u, cfg, plants); },
+        update: function (dt, camera, sunWorld, renderer) {
+            object.updateWorldMatrix(true, true);
+            object.getWorldScale(F);
+            F.set(Math.max(F.x, 1e-3), Math.max(F.y, 1e-3), Math.max(F.z, 1e-3));
+            if (Math.abs(F.x - lastF.x) + Math.abs(F.y - lastF.y) + Math.abs(F.z - lastF.z) > 1e-4) {
+                layout();
+                object.updateWorldMatrix(false, true);
+            }
+            // impostors: the stand needs every plant's card; bake one plant at a time
+            let active = plants.find((pl) => { const st = pl.inst.lod.state; return !st.ready || st.frame >= 0 || st.dirty; });
+            for (const pl of plants)
+                pl.inst.lod.state.wanted = pl === active;
+            for (const pl of plants)
+                pl.inst.update(dt, camera, sunWorld, renderer);
+            chooseNear();
+        },
+        stats: { trees: nTrees, undergrowth: nUnder, species: plants.length },
+        dispose: function () { for (const pl of plants) {
+            pl.cards.geometry.dispose();
+            pl.inst.dispose();
+        } },
+    };
+}
+/** Knobs whose change rebuilds the plant (dispose + build); every other knob is a live push through apply. */
+export const STRUCTURAL = ['mix', 'trees', 'clumping', 'sizeVar', 'undergrowth', 'quality', 'seed', 'nearTrees'];

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

@@ -0,0 +1,99 @@
+import * as THREE from 'three';
+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 build(u: any, c: any): {
+    object: THREE.Group<THREE.Object3DEventMap>;
+    materials: THREE.MeshPhysicalMaterial[];
+    apply: (cfg: any) => void;
+    update: (dt: any, camera: any, sunWorld: any) => void;
+    stats: {
+        pieces: number;
+        verts: 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=fruit.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fruit.d.ts","sourceRoot":"","sources":["../../../../src/components/vegetation/core/fruit.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAI/B,wBAAgB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAqC;AAEnE,wBAAgB,WAAW,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA,EAAE,IAAI,KAAA,QAarC;AAED,wBAAgB,KAAK,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA;;;;;;;;;;EAyCzB;AAED,8GAA8G;AAC9G,eAAO,MAAM,UAAU,UAAuC,CAAC"}

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

@@ -0,0 +1,77 @@
+// Emitted from Claude outputs/vegetation-lab/fruit.mjs by gen_family.mjs — edit the lab module and re-emit.
+// Fruit — vegetation object (lab module). Engine: ./produce.mjs (shared with vegetable).
+// Construction: one kind of fruit, as a single piece or a pile resting on the ground. Each kind is
+// a lathe profile with per-kind lobes, dimples, bumps and lattices (apple, orange, lemon, pear,
+// banana, cherry, strawberry, grapes, watermelon, pineapple), its stem and leaf / crown, and a skin
+// that ripens from one colour to another with the kind's pattern, gloss and translucency. The
+// cursor squeezes the flesh, ripens what it warms, or scatters a pile. Size: the unit box.
+import * as THREE from 'three';
+import { mulberry32, setColor, createCommonUniforms, applyCommonConfig, updateCommon, QUALITY_V, unitBounds, plantMesh } from '../vegetationCore.js';
+import { PRODUCE, buildPiece, produceMaterial, instancePieces, pilePlacement, applyKind } from '../produceCore.js';
+export function createUniforms() { return createCommonUniforms(); }
+export function applyConfig(u, c, mats) {
+    // the family's `color` is the skin tint here and `shadeColor` the greens (leaves, calyx, crown)
+    applyCommonConfig(u, Object.assign({}, c, { color: c.shadeColor, shadeColor: undefined }));
+    if (!mats)
+        return;
+    const o = mats.skin.userData.uniforms;
+    const P = PRODUCE[c.kind] || PRODUCE.apple;
+    if (c.kind !== undefined)
+        applyKind(mats.skin, P);
+    if (c.ripeness !== undefined)
+        o.uRipeness.value = c.ripeness;
+    if (c.sizeVar !== undefined)
+        o.uSizeVar.value = c.sizeVar;
+    if (c.blemish !== undefined)
+        o.uBlemish.value = c.blemish;
+    if (c.gloss !== undefined)
+        o.uGloss.value = P.gloss * c.gloss;
+    if (c.color !== undefined)
+        setColor(o.uTint, c.color);
+    if (c.count !== undefined)
+        o.uCount.value = c.count;
+}
+export function build(u, c) {
+    const q = QUALITY_V[c.quality] || 1;
+    const kind = PRODUCE[c.kind] ? c.kind : 'apple';
+    const P = PRODUCE[kind];
+    const rnd = mulberry32((c.seed ?? 5) * 2654435761 + 5);
+    const count = Math.max(1, Math.round(c.count ?? 1));
+    let pair_setPieceH = 1;
+    const piece = buildPiece(kind, c.seed ?? 5, Math.min(1.6, 0.8 + 0.5 * q));
+    // fit: a single piece fills the box; a pile's footprint does
+    const ext = Math.max(piece.height, piece.width);
+    const foot = count <= 1 ? 1 : Math.min(0.5, 0.82 / Math.sqrt(count)) * (P.small ? 1.15 : 1);
+    const s = foot / ext;
+    piece.geo.scale(s, s, s);
+    const geo = instancePieces(piece.geo, count);
+    // lying kinds (carrot, banana, corn, cucumber) take their length as footprint and rest on their side
+    const foot2 = P.lie ? piece.height * s : piece.width * s;
+    const places = pilePlacement(count, foot2, rnd, count <= 1 || !!P.invert || !!P.crown || !!P.tops || !!P.mushroom || !!P.wrap, !!P.lie, piece.width * s * 0.5);
+    pair_setPieceH = piece.height * s;
+    for (let i = 0; i < count; i++) {
+        const p = places[i] || places[0];
+        geo.attributes.aXf.setXYZW(i, p.x, p.y, p.z, p.yaw);
+        geo.attributes.aTilt.setXYZW(i, p.tiltX, p.tiltZ, p.tilt, 1);
+        geo.attributes.aPiece.setXYZW(i, rnd(), i / count, rnd(), 0);
+    }
+    unitBounds(geo);
+    const pair = produceMaterial(u);
+    pair.material.userData.uniforms.uPieceH.value = pair_setPieceH;
+    const mesh = plantMesh(geo, pair, 'fruit');
+    const object = new THREE.Group();
+    object.name = 'fruit';
+    object.add(mesh);
+    const mats = { skin: pair.material };
+    applyConfig(u, c, mats);
+    return {
+        object,
+        materials: [pair.material],
+        apply: function (cfg) { applyConfig(u, cfg, mats); },
+        update: function (dt, camera, sunWorld) { updateCommon(u, object, camera, dt, sunWorld); },
+        stats: { pieces: count, verts: piece.geo.attributes.position.count },
+        dispose: function () { geo.dispose(); piece.geo.dispose(); pair.material.dispose(); pair.depth.dispose(); },
+    };
+}
+/** Knobs whose change rebuilds the plant (dispose + build); every other knob is a live push through apply. */
+export const STRUCTURAL = ['kind', 'count', 'quality', 'seed'];

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

@@ -0,0 +1,103 @@
+import * as THREE from 'three';
+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;
+    };
+} & {
+    uLeafType: {
+        value: number;
+    };
+};
+export declare function applyConfig(u: any, c: any, mats: any): void;
+export declare function build(u: any, c: any): {
+    object: THREE.Group<THREE.Object3DEventMap>;
+    materials: THREE.MeshStandardMaterial[];
+    apply: (cfg: any) => void;
+    update: (dt: any, camera: any, sunWorld: any) => void;
+    stats: {
+        blades: number;
+        flowers: 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=grass.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"grass.d.ts","sourceRoot":"","sources":["../../../../src/components/vegetation/core/grass.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAQ/B,wBAAgB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA2G;AAEzI,wBAAgB,WAAW,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA,EAAE,IAAI,KAAA,QAKrC;AAED,wBAAgB,KAAK,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA;;;;;;;;;;EAgEzB;AAED,8GAA8G;AAC9G,eAAO,MAAM,UAAU,UAAgE,CAAC"}