@3driseai/3drise-viewer 0.1.42 → 0.1.44

package/dist/components/vegetation/produceCore.js

@@ -0,0 +1,723 @@
+// Emitted from Claude outputs/vegetation-lab/produce.mjs by gen_family.mjs — edit the lab module and re-emit.
+// Produce — shared engine of the fruit and vegetable objects (lab). Inlined after common.mjs.
+//
+// Every kind is one profile: a lathe radius function ρ(t) along the height (t = 0 bottom .. 1 top),
+// a cross-section modulation (lobes / ribs: cos(nθ)), per-kind displacement (dimples, kernels,
+// bumps, warts) from seeded value noise, an elongation, a stem and a leaf / calyx, and a skin:
+// two colours by ripeness, a pattern (stripes, streaks, pores, netting), gloss and translucency.
+// The mesh is a parametric surface (u around, v along) built on the CPU with finite-difference
+// normals, once per kind; a pile is instanced copies resting on the ground.
+//
+// Compound kinds build on the same primitive: grapes = many small spheroids on a cone, broccoli =
+// a stalk + a dome of florets, pineapple = ovoid lattice + crown blades, corn = cob + husk blades,
+// banana = a curved tube (a bent lathe).
+import * as THREE from 'three';
+import { mulberry32, NOISE_GLSL_V, VEG_UNIFORMS_GLSL, WIND_GLSL, LEAF_SDF_GLSL, LEAF_TYPES, leafGeometry, setLeaf, unitBounds } from './vegetationCore.js';
+const TAU = Math.PI * 2;
+// ρ(t) helpers
+const ell = (t, p) => Math.pow(Math.max(0, Math.sin(Math.PI * t)), p || 1);
+export const PRODUCE = {
+    // ------------------------------------------------------------------ fruit
+    apple: { h: 0.9, rho: (t) => 0.5 * ell(t, 0.62) * (1 - 0.12 * t), lobes: [5, 0.015], dimple: [0.12, 0.18], unripe: '#8fbf3f', ripe: '#c9302b', pattern: 'streaks', gloss: 0.55, sss: 0.3, stem: [0.1, 0.012, '#4a3a2a'], leaf: 1 },
+    orange: { h: 0.95, rho: (t) => 0.5 * ell(t, 0.58), lobes: [0, 0], dimple: [0.04, 0.06], bumps: [9, 0.01], unripe: '#7faf3a', ripe: '#f08a1f', pattern: 'pores', gloss: 0.3, sss: 0.15, stem: [0.03, 0.01, '#4a4a2a'], leaf: 0 },
+    lemon: { h: 1.0, rho: (t) => 0.42 * ell(t, 0.7) + 0.05 * Math.max(0, 1 - Math.abs(t - 0.5) * 3), lobes: [0, 0], dimple: [-0.08, -0.1], bumps: [8, 0.012], unripe: '#8fbf3f', ripe: '#f4d82a', pattern: 'pores', gloss: 0.4, sss: 0.2, stem: [0.03, 0.01, '#4a4a2a'], leaf: 0 },
+    pear: { h: 1.0, rho: (t) => 0.42 * (ell(t, 0.5) * (1 - 0.55 * Math.pow(t, 1.5)) + 0.12 * t * (1 - t)), lobes: [5, 0.01], dimple: [0.06, 0.1], unripe: '#9cc44a', ripe: '#d1c243', pattern: 'speckle', gloss: 0.25, sss: 0.2, stem: [0.14, 0.012, '#5a4a3a'], leaf: 0 },
+    banana: { h: 1.0, rho: (t) => 0.14 * ell(t, 0.3) * (1 - 0.3 * t), lobes: [5, 0.12], dimple: [0, 0], bend: 0.9, unripe: '#8fbf3f', ripe: '#f2d53a', pattern: 'banana', gloss: 0.35, sss: 0.1, stem: [0.08, 0.03, '#5a4a2a'], leaf: 0, lie: true },
+    cherry: { h: 0.9, rho: (t) => 0.5 * ell(t, 0.6), lobes: [2, 0.02], dimple: [0.1, 0.14], unripe: '#e0c050', ripe: '#8a1324', pattern: 'none', gloss: 0.95, sss: 0.35, stem: [0.9, 0.012, '#4a7a2a'], leaf: 0, small: 0.35, pairs: true },
+    strawberry: { h: 1.0, rho: (t) => 0.46 * Math.pow(ell(t, 0.5), 0.8) * (1 - 0.75 * Math.pow(t, 1.3)), lobes: [0, 0], dimple: [0, 0], seeds: [34, 0.018], unripe: '#dfe09a', ripe: '#d61f2c', pattern: 'seeds', gloss: 0.65, sss: 0.3, stem: [0.05, 0.015, '#3f7a2a'], leaf: 0, calyx: 7, small: 0.45, invert: true },
+    grapes: { h: 1.0, rho: (t) => 0.3, cluster: { n: 56, rad: 0.11, cone: 0.5 }, unripe: '#9fcf5a', ripe: '#4a2c66', pattern: 'bloom', gloss: 0.6, sss: 0.4, stem: [0.2, 0.012, '#6a7a3a'], leaf: 1 },
+    watermelon: { h: 0.78, rho: (t) => 0.5 * ell(t, 0.5), lobes: [0, 0], dimple: [0.03, 0.03], unripe: '#7a9a4a', ripe: '#2f6a2f', pattern: 'stripes', gloss: 0.3, sss: 0, stem: [0.08, 0.02, '#6a6a4a'], leaf: 0, big: 1.6 },
+    pineapple: { h: 1.0, rho: (t) => 0.4 * ell(t, 0.45) * (1 - 0.15 * t), lobes: [0, 0], dimple: [0, 0], lattice: [10, 0.04], unripe: '#7a9a3a', ripe: '#d9a53a', pattern: 'lattice', gloss: 0.3, sss: 0.1, stem: [0, 0, '#000'], leaf: 0, crown: 14, big: 1.1 },
+    // ---- more fruit
+    peach: { h: 0.9, rho: (t) => 0.5 * ell(t, 0.6), lobes: [0, 0], dimple: [0.1, 0.12], cleft: 0.08, unripe: '#c9c07a', ripe: '#f0a060', pattern: 'blush', gloss: 0.05, sss: 0.4, fuzz: 1, stem: [0.03, 0.012, '#5a4a3a'], leaf: 1 },
+    apricot: { h: 0.85, rho: (t) => 0.5 * ell(t, 0.6), lobes: [0, 0], dimple: [0.08, 0.1], cleft: 0.1, unripe: '#c9c070', ripe: '#f2a23a', pattern: 'blush', gloss: 0.1, sss: 0.4, fuzz: 0.6, stem: [0.03, 0.01, '#5a4a3a'], leaf: 0, small: 0.6 },
+    plum: { h: 0.95, rho: (t) => 0.48 * ell(t, 0.6), lobes: [0, 0], dimple: [0.08, 0.1], cleft: 0.06, unripe: '#8aa34a', ripe: '#4a1d4f', pattern: 'bloom', gloss: 0.7, sss: 0.3, stem: [0.1, 0.01, '#5a4a3a'], leaf: 0, small: 0.6 },
+    mango: { h: 1.0, rho: (t) => 0.4 * (ell(t, 0.5) * (1 - 0.35 * t) + 0.05 * (1 - t)), lobes: [2, 0.08], dimple: [0.02, 0.04], bend: 0.35, unripe: '#6fa33a', ripe: '#f0b830', pattern: 'blush', gloss: 0.5, sss: 0.3, stem: [0.04, 0.012, '#5a4a3a'], leaf: 0, lie: true },
+    kiwi: { h: 1.0, rho: (t) => 0.38 * ell(t, 0.55), lobes: [0, 0], dimple: [0, 0], unripe: '#9a8a5a', ripe: '#8a6a3a', pattern: 'speckle', gloss: 0.0, sss: 0.1, fuzz: 1, stem: [0, 0, '#000'], leaf: 0, small: 0.6, lie: true },
+    lime: { h: 0.9, rho: (t) => 0.46 * ell(t, 0.62), lobes: [0, 0], dimple: [-0.03, -0.04], bumps: [8, 0.01], unripe: '#4e9a2f', ripe: '#6fbf2f', pattern: 'pores', gloss: 0.45, sss: 0.2, stem: [0.02, 0.008, '#4a4a2a'], leaf: 0, small: 0.6 },
+    grapefruit: { h: 0.9, rho: (t) => 0.5 * ell(t, 0.6), lobes: [0, 0], dimple: [0.05, 0.06], bumps: [8, 0.008], unripe: '#9fbf4a', ripe: '#f2c24a', pattern: 'pores', gloss: 0.3, sss: 0.15, stem: [0.02, 0.01, '#4a4a2a'], leaf: 0, big: 1.3 },
+    pomegranate: { h: 1.0, rho: (t) => 0.48 * ell(t, 0.55) * (1 - 0.1 * t), lobes: [6, 0.03], dimple: [0.0, 0.08], unripe: '#c9a060', ripe: '#b8242a', pattern: 'speckle', gloss: 0.4, sss: 0.1, stem: [0, 0, '#000'], leaf: 0, calyx: 6, calyxUp: 1 },
+    fig: { h: 1.0, rho: (t) => 0.42 * (ell(t, 0.5) * (1 - 0.6 * Math.pow(t, 1.3)) + 0.06 * t * (1 - t)), lobes: [5, 0.02], dimple: [0, 0.06], unripe: '#7fa34a', ripe: '#4a2a5a', pattern: 'streaks', gloss: 0.3, sss: 0.3, stem: [0.1, 0.012, '#5a4a3a'], leaf: 0, small: 0.6 },
+    avocado: { h: 1.0, rho: (t) => 0.4 * (ell(t, 0.5) * (1 - 0.5 * Math.pow(t, 1.5)) + 0.08 * t * (1 - t)), lobes: [0, 0], dimple: [0, 0], bumps: [12, 0.012], unripe: '#4e8a2a', ripe: '#2a3a1a', pattern: 'warts', gloss: 0.15, sss: 0.05, stem: [0.03, 0.01, '#4a3a2a'], leaf: 0 },
+    coconut: { h: 1.0, rho: (t) => 0.42 * ell(t, 0.5) * (1 - 0.1 * t), lobes: [3, 0.05], dimple: [0.0, 0.0], unripe: '#7a6a4a', ripe: '#5a3f22', pattern: 'fibre', gloss: 0.0, sss: 0.0, stem: [0, 0, '#000'], leaf: 0, big: 1.2 },
+    melon: { h: 0.85, rho: (t) => 0.5 * ell(t, 0.55), lobes: [10, 0.015], dimple: [0.04, 0.04], unripe: '#9aa86a', ripe: '#c9b878', pattern: 'net', gloss: 0.1, sss: 0.0, stem: [0.04, 0.02, '#8a7a5a'], leaf: 0, big: 1.4 },
+    papaya: { h: 1.0, rho: (t) => 0.3 * (ell(t, 0.4) * (1 - 0.3 * t) + 0.05), lobes: [5, 0.04], dimple: [0, 0.03], unripe: '#5f9a3a', ripe: '#f0a03a', pattern: 'streaks', gloss: 0.4, sss: 0.2, stem: [0.03, 0.02, '#6a6a4a'], leaf: 0, lie: true, big: 1.2 },
+    dragonfruit: { h: 1.0, rho: (t) => 0.4 * ell(t, 0.55), lobes: [0, 0], dimple: [0, 0.04], lattice: [8, 0.03], unripe: '#8ab85a', ripe: '#e8307a', pattern: 'scales', gloss: 0.5, sss: 0.2, stem: [0, 0, '#000'], leaf: 0, scaleTips: 12 },
+    persimmon: { h: 0.75, rho: (t) => 0.5 * ell(t, 0.5), lobes: [4, 0.03], dimple: [0.08, 0.1], unripe: '#9fbf4a', ripe: '#f07a2a', pattern: 'none', gloss: 0.7, sss: 0.3, stem: [0.02, 0.012, '#5a4a3a'], leaf: 0, calyx: 4, calyxFlat: 1 },
+    raspberry: { h: 1.0, rho: (t) => 0.3, cluster: { n: 42, rad: 0.11, cone: 0.32, tight: true }, unripe: '#f0d0a0', ripe: '#d8203a', pattern: 'none', gloss: 0.6, sss: 0.4, stem: [0, 0, '#000'], leaf: 0, small: 0.35 },
+    blueberry: { h: 0.8, rho: (t) => 0.48 * ell(t, 0.6), lobes: [0, 0], dimple: [0.25, 0.05], unripe: '#9fcf7a', ripe: '#3a3f7a', pattern: 'bloom', gloss: 0.5, sss: 0.2, stem: [0, 0, '#000'], leaf: 0, small: 0.3 },
+    cherryPair: { h: 0.9, rho: (t) => 0.5 * ell(t, 0.6), lobes: [2, 0.02], dimple: [0.1, 0.14], unripe: '#e0c050', ripe: '#8a1324', pattern: 'none', gloss: 0.95, sss: 0.35, stem: [0.9, 0.012, '#4a7a2a'], leaf: 0, small: 0.35, pairs: true, hidden: true },
+    zucchini: { h: 1.0, rho: (t) => 0.13 * ell(Math.min(1, 0.25 + t * 0.6), 0.3) * (1 - 0.15 * t) + 0.03 * ell(t, 0.3), lobes: [5, 0.04], dimple: [0, 0], unripe: '#4e9a3a', ripe: '#2f5a2a', pattern: 'speckle', gloss: 0.6, sss: 0.1, stem: [0.06, 0.03, '#5a7a2a'], leaf: 0, lie: true, bend: 0.1 },
+    radish: { h: 0.8, rho: (t) => 0.42 * ell(Math.min(1, t * 1.15), 0.55), lobes: [0, 0], dimple: [0, 0], unripe: '#e8a0b0', ripe: '#d8203a', pattern: 'none', gloss: 0.5, sss: 0.2, stem: [0, 0, '#000'], leaf: 0, tops: 6, roots: 1, invert: true, small: 0.5 },
+    beet: { h: 0.9, rho: (t) => 0.46 * ell(Math.min(1, t * 1.1), 0.55), lobes: [0, 0], dimple: [0, 0], rings: [10, 0.004], unripe: '#a04a5a', ripe: '#5a1a3a', pattern: 'rings', gloss: 0.3, sss: 0.1, stem: [0, 0, '#000'], leaf: 0, tops: 6, roots: 1, invert: true, small: 0.7 },
+    turnip: { h: 0.8, rho: (t) => 0.46 * ell(Math.min(1, t * 1.1), 0.55), lobes: [0, 0], dimple: [0, 0], unripe: '#e8e0d0', ripe: '#b060a0', pattern: 'turnip', gloss: 0.3, sss: 0.2, stem: [0, 0, '#000'], leaf: 0, tops: 6, roots: 1, invert: true, small: 0.7 },
+    cauliflower: { h: 1.0, rho: (t) => 0.1, florets: { n: 140, rad: 0.075, dome: 0.4 }, unripe: '#f0ecd8', ripe: '#f4f0e0', pattern: 'florets', gloss: 0.05, sss: 0.1, stem: [0.4, 0.1, '#9ab878'], leaf: 0, wrap: 8 },
+    cabbage: { h: 0.85, rho: (t) => 0.5 * ell(t, 0.55), lobes: [0, 0], dimple: [0.05, 0.05], unripe: '#8fbf6a', ripe: '#7fb05a', pattern: 'veined', gloss: 0.3, sss: 0.3, stem: [0, 0, '#000'], leaf: 0, wrap: 7 },
+    garlic: { h: 0.9, rho: (t) => 0.46 * ell(t, 0.55) * (1 - 0.4 * Math.pow(t, 3)), lobes: [7, 0.09], dimple: [0.02, 0.05], unripe: '#f0e8dc', ripe: '#e8dcc8', pattern: 'cloves', gloss: 0.2, sss: 0.4, stem: [0.2, 0.03, '#c8b890'], leaf: 0, roots: 1, small: 0.6 },
+    chili: { h: 1.0, rho: (t) => 0.1 * ell(Math.min(1, 0.15 + t * 0.9), 0.35) * (1 - 0.6 * Math.pow(t, 2)) + 0.01, lobes: [3, 0.03], dimple: [0, 0], bend: 0.5, unripe: '#4e9a2f', ripe: '#d81e1e', pattern: 'none', gloss: 0.9, sss: 0.25, stem: [0.08, 0.025, '#4f7a2a'], leaf: 0, lie: true, small: 0.6, invert: true },
+    sweetPotato: { h: 1.0, rho: (t) => 0.22 * (ell(t, 0.5) * (1 - 0.2 * t) + 0.03), lobes: [3, 0.04], dimple: [0, 0], bumps: [6, 0.03], unripe: '#c07a5a', ripe: '#a0503a', pattern: 'eyes', gloss: 0.05, sss: 0.0, stem: [0, 0, '#000'], leaf: 0, lie: true },
+    butternut: { h: 1.0, rho: (t) => 0.32 * (ell(t, 0.45) * (0.55 + 0.45 * (1 - t)) + 0.08 * t * (1 - t)), lobes: [0, 0], dimple: [0.02, 0.06], unripe: '#c9b878', ripe: '#e8b870', pattern: 'none', gloss: 0.25, sss: 0.1, stem: [0.08, 0.03, '#6a5a2a'], leaf: 0, lie: true, big: 1.2 },
+    leek: { h: 1.0, rho: (t) => 0.09 * (1 - 0.2 * t) + 0.01, lobes: [0, 0], dimple: [0, 0], unripe: '#e8f0e0', ripe: '#d8e8c8', pattern: 'leek', gloss: 0.3, sss: 0.3, stem: [0, 0, '#000'], leaf: 0, tops: 5, topsBlade: 1, roots: 1, lie: true },
+    asparagus: { h: 1.0, rho: (t) => 0.05 * (1 - 0.3 * t) + 0.01, lobes: [0, 0], dimple: [0.0, 0.0], rings: [16, 0.004], unripe: '#8fbf5a', ripe: '#5a9a3a', pattern: 'spear', gloss: 0.4, sss: 0.3, stem: [0, 0, '#000'], leaf: 0, lie: true, small: 0.5 },
+    artichoke: { h: 1.0, rho: (t) => 0.42 * ell(Math.min(1, 0.2 + t * 0.8), 0.5) * (1 - 0.25 * t), lobes: [0, 0], dimple: [0, 0], lattice: [9, 0.05], unripe: '#7fa35a', ripe: '#5f8a4a', pattern: 'lattice', gloss: 0.2, sss: 0.1, stem: [0.2, 0.04, '#7a9a5a'], leaf: 0, invert: true },
+    mushroom: { h: 1.0, rho: (t) => 0.1, mushroom: { capR: 0.5, capH: 0.3, stemH: 0.6, stemR: 0.1 }, unripe: '#e8dcc8', ripe: '#c8a070', pattern: 'cap', gloss: 0.1, sss: 0.3, stem: [0, 0, '#000'], leaf: 0 },
+    flyAgaric: { h: 1.0, rho: (t) => 0.1, mushroom: { capR: 0.5, capH: 0.35, stemH: 0.7, stemR: 0.09 }, unripe: '#f0a040', ripe: '#d8201e', pattern: 'spots', gloss: 0.6, sss: 0.2, stem: [0, 0, '#000'], leaf: 0 },
+    peaPod: { h: 1.0, rho: (t) => 0.1 * ell(Math.min(1, 0.1 + t * 0.9), 0.4) + 0.01, lobes: [2, 0.25], dimple: [0, 0], bend: 0.3, pods: 6, unripe: '#8fc85a', ripe: '#6fa83a', pattern: 'pod', gloss: 0.5, sss: 0.4, stem: [0.06, 0.015, '#5a8a3a'], leaf: 0, lie: true, small: 0.6 },
+    beans: { h: 1.0, rho: (t) => 0.07 * ell(Math.min(1, 0.1 + t * 0.9), 0.35) + 0.01, lobes: [2, 0.2], dimple: [0, 0], bend: 0.5, pods: 7, unripe: '#8fc85a', ripe: '#5a9a3a', pattern: 'pod', gloss: 0.4, sss: 0.3, stem: [0.05, 0.012, '#5a8a3a'], leaf: 0, lie: true, small: 0.6 },
+    wheatHead: { h: 1.0, rho: (t) => 0.1 * ell(Math.min(1, 0.1 + t * 0.9), 0.4), lobes: [4, 0.15], dimple: [0, 0], kernels: [6, 0.05], unripe: '#9fbf5a', ripe: '#d8b860', pattern: 'kernels', gloss: 0.2, sss: 0.3, stem: [0, 0, '#000'], leaf: 0, hidden: true, awns: 1 },
+    sunflowerHead: { h: 0.35, rho: (t) => 0.5 * ell(Math.min(1, t * 1.3), 0.35), lobes: [0, 0], dimple: [0.15, 0.0], unripe: '#6a5a2a', ripe: '#4a2a12', pattern: 'disc', gloss: 0.1, sss: 0.0, stem: [0, 0, '#000'], leaf: 0, rays: 26, hidden: true },
+    // ------------------------------------------------------------------ vegetables
+    tomato: { h: 0.82, rho: (t) => 0.5 * ell(t, 0.55), lobes: [6, 0.03], dimple: [0.1, 0.16], unripe: '#8fbf3f', ripe: '#d8321e', pattern: 'none', gloss: 0.85, sss: 0.35, stem: [0.06, 0.015, '#4f7a2a'], leaf: 0, calyx: 5 },
+    pepper: { h: 1.0, rho: (t) => 0.42 * (ell(t, 0.35) * (1 - 0.2 * t) + 0.05 * (1 - t)), lobes: [4, 0.14], dimple: [0.12, 0.08], unripe: '#4e9a2f', ripe: '#d8281c', pattern: 'none', gloss: 0.9, sss: 0.2, stem: [0.1, 0.03, '#4f7a2a'], leaf: 0, calyx: 0 },
+    pumpkin: { h: 0.7, rho: (t) => 0.5 * ell(t, 0.5), lobes: [12, 0.07], dimple: [0.18, 0.2], unripe: '#9aa84a', ripe: '#e07a1a', pattern: 'ribs', gloss: 0.3, sss: 0, stem: [0.12, 0.05, '#6a5a2a'], leaf: 0, big: 1.5 },
+    carrot: { h: 1.0, rho: (t) => 0.13 * Math.pow(1 - t, 0.6) * ell(Math.min(1, 0.5 + t * 0.5), 0.5) + 0.01, lobes: [0, 0], dimple: [0, 0], rings: [24, 0.01], unripe: '#f0a040', ripe: '#f07a1a', pattern: 'rings', gloss: 0.3, sss: 0.1, stem: [0, 0, '#000'], leaf: 0, tops: 9, invert: true, small: 0.6, lie: true },
+    corn: { h: 1.0, rho: (t) => 0.17 * ell(Math.min(1, 0.3 + t * 0.7), 0.4) * (1 - 0.25 * t), lobes: [0, 0], dimple: [0, 0], kernels: [14, 0.02], unripe: '#e8e0a0', ripe: '#f2c22a', pattern: 'kernels', gloss: 0.6, sss: 0.3, stem: [0, 0, '#000'], leaf: 0, husk: 5, lie: true },
+    cucumber: { h: 1.0, rho: (t) => 0.14 * ell(Math.min(1, Math.max(0, 0.2 + t * 0.6)), 0.3) * (1 - 0.1 * t) + 0.03 * ell(t, 0.3), lobes: [0, 0], dimple: [0, 0], bumps: [7, 0.012], unripe: '#4e9a3a', ripe: '#2f6a2f', pattern: 'warts', gloss: 0.5, sss: 0.1, stem: [0.04, 0.015, '#5a7a2a'], leaf: 0, bend: 0.15, lie: true },
+    eggplant: { h: 1.0, rho: (t) => 0.4 * (ell(t, 0.45) * (1 - 0.5 * Math.pow(t, 1.4)) + 0.1 * t * (1 - t)), lobes: [0, 0], dimple: [0.04, 0.06], unripe: '#9a6ab8', ripe: '#2f1a3a', pattern: 'none', gloss: 0.95, sss: 0.15, stem: [0.12, 0.03, '#4f7a2a'], leaf: 0, calyx: 5 },
+    broccoli: { h: 1.0, rho: (t) => 0.1, florets: { n: 120, rad: 0.07, dome: 0.42 }, unripe: '#4f8a3a', ripe: '#2f6a3a', pattern: 'florets', gloss: 0.1, sss: 0.1, stem: [0.5, 0.11, '#8aa868'], leaf: 0 },
+    potato: { h: 0.75, rho: (t) => 0.48 * ell(t, 0.55), lobes: [3, 0.04], dimple: [0, 0], bumps: [8, 0.05], eyes: [10, 0.03], unripe: '#c9a86a', ripe: '#a8824a', pattern: 'eyes', gloss: 0.05, sss: 0, stem: [0, 0, '#000'], leaf: 0 },
+    onion: { h: 1.0, rho: (t) => 0.46 * ell(t, 0.6) * (1 - 0.35 * Math.pow(t, 2.5)), lobes: [0, 0], dimple: [0.05, 0.02], unripe: '#e8d2a8', ripe: '#c9893a', pattern: 'onion', gloss: 0.5, sss: 0.3, stem: [0.14, 0.02, '#b89a6a'], leaf: 0, roots: 1 },
+};
+export const FRUIT_LIST = ['apple', 'pear', 'peach', 'apricot', 'plum', 'cherry', 'orange', 'lemon', 'lime', 'grapefruit', 'banana', 'mango', 'papaya', 'kiwi', 'fig', 'avocado', 'pomegranate', 'persimmon', 'strawberry', 'raspberry', 'blueberry', 'grapes', 'watermelon', 'melon', 'pineapple', 'dragonfruit', 'coconut'];
+export const VEGETABLE_LIST = ['tomato', 'pepper', 'chili', 'eggplant', 'cucumber', 'zucchini', 'pumpkin', 'butternut', 'corn', 'carrot', 'radish', 'beet', 'turnip', 'potato', 'sweetPotato', 'onion', 'garlic', 'leek', 'asparagus', 'broccoli', 'cauliflower', 'cabbage', 'artichoke', 'peaPod', 'beans', 'mushroom', 'flyAgaric'];
+export const PATTERNS = ['none', 'streaks', 'pores', 'speckle', 'banana', 'seeds', 'bloom', 'stripes', 'lattice', 'ribs', 'rings', 'kernels', 'warts', 'florets', 'eyes', 'onion', 'blush', 'fibre', 'net', 'scales', 'turnip', 'veined', 'cloves', 'leek', 'spear', 'cap', 'spots', 'pod', 'disc'];
+/**
+ * The body of one kind as a parametric surface in a unit-ish frame (height ≈ h, width ≈ 2·max ρ),
+ * y up from 0. Attributes: position, normal, uv (θ/2π, t), aSkin (t, noise seed). Returns the
+ * geometry and the attachment points (stem top, calyx).
+ */
+export function produceBody(kind, seed, detail) {
+    const P = PRODUCE[kind];
+    const rnd = mulberry32(seed * 1664525 + 1013904223);
+    const nu = Math.round(36 * (detail || 1)), nv = Math.round(28 * (detail || 1));
+    const pos = [], uv = [], skin = [], idx = [];
+    const lobesN = P.lobes ? P.lobes[0] : 0, lobesA = P.lobes ? P.lobes[1] : 0;
+    const noiseSeed = rnd() * 100;
+    const nz = (a, b) => {
+        const h = (x, y) => { const s = Math.sin(x * 127.1 + y * 311.7 + noiseSeed) * 43758.5453; return s - Math.floor(s); };
+        const i = Math.floor(a), j = Math.floor(b), fa = a - i, fb = b - j, sa = fa * fa * (3 - 2 * fa), sb = fb * fb * (3 - 2 * fb);
+        return (h(i, j) * (1 - sa) + h(i + 1, j) * sa) * (1 - sb) + (h(i, j + 1) * (1 - sa) + h(i + 1, j + 1) * sa) * sb;
+    };
+    const radiusAt = (th, t) => {
+        let r = P.rho(t) * (1 + lobesA * Math.cos(lobesN * th));
+        if (P.bumps)
+            r += P.bumps[1] * (nz(th / TAU * P.bumps[0], t * P.bumps[0] * 0.5) - 0.5) * 2 * ell(t, 0.3);
+        if (P.rings)
+            r += P.rings[1] * Math.sin(t * P.rings[0] * TAU) * (1 - t);
+        if (P.kernels)
+            r += P.kernels[1] * (0.5 + 0.5 * Math.cos(P.kernels[0] * th + Math.floor(t * 30) * Math.PI)) * Math.abs(Math.sin(t * 30 * Math.PI)) * ell(t, 0.3);
+        if (P.lattice)
+            r += P.lattice[1] * Math.abs(Math.sin(P.lattice[0] * th * 0.5 + t * 14) * Math.sin(P.lattice[0] * th * 0.5 - t * 14)) * ell(t, 0.3);
+        if (P.seeds)
+            r -= P.seeds[1] * Math.pow(Math.max(0, Math.cos(P.seeds[0] * th * 0.5 + t * 22) * Math.cos(P.seeds[0] * th * 0.5 - t * 22)), 4) * ell(t, 0.3);
+        if (P.eyes)
+            r -= P.eyes[1] * Math.pow(nz(th / TAU * P.eyes[0] * 0.5 + 9, t * 3 + 4), 8) * 10 * ell(t, 0.3);
+        if (P.cleft) {
+            const da = Math.atan2(Math.sin(th), Math.cos(th));
+            r -= P.cleft * Math.exp(-da * da / 0.05) * ell(t, 0.4);
+        } // the seam of a stone fruit
+        if (P.pods)
+            r *= 1 + 0.4 * Math.pow(Math.abs(Math.sin(t * P.pods * Math.PI)), 1.5) * Math.max(0, Math.cos(th)) * 0.8 + 0.15 * Math.pow(Math.abs(Math.sin(t * P.pods * Math.PI)), 1.5); // peas / beans bulging the pod
+        r *= 1 + 0.02 * (nz(th / TAU * 3 + 20, t * 2) - 0.5);
+        return Math.max(r, 0.002);
+    };
+    const dimpleY = (th, t) => {
+        // poles pushed in (apple, tomato) or out (lemon nipple)
+        const top = P.dimple ? P.dimple[0] : 0, bot = P.dimple ? P.dimple[1] : 0;
+        const rr = P.rho(t) / Math.max(P.rho(0.5), 1e-3);
+        return -top * Math.pow(Math.max(0, 1 - rr * 1.2), 1.5) * (t > 0.5 ? 1 : 0) + bot * Math.pow(Math.max(0, 1 - rr * 1.2), 1.5) * (t <= 0.5 ? 1 : 0);
+    };
+    const point = (th, t, out) => {
+        const r = radiusAt(th, t);
+        let x = Math.cos(th) * r, z = Math.sin(th) * r, y = t * P.h + dimpleY(th, t);
+        if (P.bend) { // banana / cucumber: bend the axis along x
+            const b = P.bend * (t - 0.5) * (t - 0.5) * 2;
+            x += b - P.bend * 0.1;
+            const ang = P.bend * (t - 0.5) * 1.2;
+            const cy = y - 0.5 * P.h;
+            const nx = x * Math.cos(ang) - cy * Math.sin(ang), ny = x * Math.sin(ang) + cy * Math.cos(ang);
+            x = nx;
+            y = ny + 0.5 * P.h;
+        }
+        return out.set(x, y, z);
+    };
+    const p = new THREE.Vector3(), pa = new THREE.Vector3(), pb = new THREE.Vector3(), n = new THREE.Vector3();
+    const nrm = [];
+    for (let j = 0; j <= nv; j++) {
+        const t = j / nv;
+        for (let i = 0; i <= nu; i++) {
+            const th = i / nu * TAU;
+            point(th, t, p);
+            point(th + 1e-3, t, pa).sub(p);
+            point(th, Math.min(1, t + 1e-3), pb).sub(p);
+            if (t >= 1)
+                point(th, t - 1e-3, pb).sub(p).negate();
+            n.crossVectors(pb, pa).normalize();
+            if (j === 0 || j === nv)
+                n.set(0, j === 0 ? -1 : 1, 0);
+            pos.push(p.x, p.y, p.z);
+            nrm.push(n.x, n.y, n.z);
+            uv.push(i / nu, t);
+            skin.push(t, nz(th, t * 4));
+        }
+    }
+    for (let j = 0; j < nv; j++)
+        for (let i = 0; i < nu; i++) {
+            const a = j * (nu + 1) + i, b = a + nu + 1;
+            idx.push(a, b, a + 1, a + 1, b, b + 1);
+        }
+    const geo = new THREE.BufferGeometry();
+    geo.setAttribute('position', new THREE.Float32BufferAttribute(pos, 3));
+    geo.setAttribute('normal', new THREE.Float32BufferAttribute(nrm, 3));
+    geo.setAttribute('uv', new THREE.Float32BufferAttribute(uv, 2));
+    geo.setAttribute('aSkin', new THREE.Float32BufferAttribute(skin, 2));
+    geo.setIndex(idx);
+    const top = point(0, 1, new THREE.Vector3()), bottom = point(0, 0, new THREE.Vector3());
+    return { geo, top, bottom, h: P.h, width: 2 * Math.max(P.rho(0.5), P.rho(0.3), P.rho(0.7)) };
+}
+/** Small instanced spheroids (grapes, florets): one sphere geometry with aPos/aInfo instances. */
+export function clusterGeometry(centres, rad, detail) {
+    const sph = new THREE.SphereGeometry(1, 10 * (detail || 1) | 0, 7 * (detail || 1) | 0);
+    const g = new THREE.InstancedBufferGeometry();
+    g.setAttribute('position', sph.attributes.position);
+    g.setAttribute('normal', sph.attributes.normal);
+    g.setAttribute('uv', sph.attributes.uv);
+    g.setIndex(sph.index);
+    const n = centres.length;
+    const a = new Float32Array(n * 4);
+    for (let i = 0; i < n; i++) {
+        a[i * 4] = centres[i].x;
+        a[i * 4 + 1] = centres[i].y;
+        a[i * 4 + 2] = centres[i].z;
+        a[i * 4 + 3] = rad * (0.8 + 0.4 * centres[i].s);
+    }
+    g.setAttribute('aCentre', new THREE.InstancedBufferAttribute(a, 4));
+    g.instanceCount = n;
+    return g;
+}
+// ---------------------------------------------------------------------------- the skin
+/**
+ * Produce skin: a lit material. Per piece: ripeness with a spread (colour from unripe → ripe,
+ * gloss rises with it), the kind's pattern, blemishes, translucency against the sun.
+ * Instanced: aXf = (x, y, z, yaw), aTilt = (tilt axis x, z, tilt, scale), aPiece = (hash, order, ripe offset, -).
+ */
+export function produceMaterial(u) {
+    // a physical material: the waxy skin is a clearcoat over the pigmented flesh, so highlights are sharp
+    // and white while the body colour stays matte underneath; the clearcoat follows the kind's gloss
+    const mat = new THREE.MeshPhysicalMaterial({ color: 0xffffff, roughness: 0.5, metalness: 0, side: THREE.DoubleSide, alphaToCoverage: true, clearcoat: 0.5, clearcoatRoughness: 0.2, envMapIntensity: 1.0 });
+    const own = {
+        uUnripe: { value: new THREE.Color('#8fbf3f') }, uRipe: { value: new THREE.Color('#c9302b') }, uTint: { value: new THREE.Color('#ffffff') },
+        uRipeness: { value: 1 }, uBlemish: { value: 0.2 }, uGloss: { value: 0.5 }, uSss: { value: 0.2 }, uPattern: { value: 0 }, uPieceH: { value: 1 },
+        uCount: { value: 1 }, uSizeVar: { value: 0.15 }, uStemColor: { value: new THREE.Color('#4a3a2a') },
+    };
+    mat.userData.uniforms = own;
+    const PARS = `#include <common>\n${VEG_UNIFORMS_GLSL}\n${NOISE_GLSL_V}\n${WIND_GLSL}
+uniform float uRipeness, uCount, uSizeVar, uPieceH;
+attribute vec2 aSkin; attribute vec2 aPart; attribute vec2 aCard; attribute vec4 aXf; attribute vec4 aTilt; attribute vec4 aPiece; attribute vec3 aRoot;
+varying vec2 vSkin; varying vec3 vPiece; varying vec3 vLocal; varying vec2 vPart; varying vec2 vCard;
+mat3 pieceRot(vec4 xf, vec4 tilt) {
+    float cy = cos(xf.w), sy = sin(xf.w);
+    mat3 yaw = mat3(cy, 0.0, -sy, 0.0, 1.0, 0.0, sy, 0.0, cy);
+    vec3 ax = normalize(vec3(tilt.x, 0.0, tilt.y) + 1e-5);
+    float ct = cos(tilt.z), st = sin(tilt.z);
+    mat3 rot = mat3(ct + ax.x * ax.x * (1.0 - ct), ax.y * ax.x * (1.0 - ct) + ax.z * st, ax.z * ax.x * (1.0 - ct) - ax.y * st,
+                    ax.x * ax.y * (1.0 - ct) - ax.z * st, ct + ax.y * ax.y * (1.0 - ct), ax.z * ax.y * (1.0 - ct) + ax.x * st,
+                    ax.x * ax.z * (1.0 - ct) + ax.y * st, ax.y * ax.z * (1.0 - ct) - ax.x * st, ct + ax.z * ax.z * (1.0 - ct));
+    return rot * yaw;
+}
+`;
+    const PRE = `
+    float sc = aTilt.w * (1.0 + uSizeVar * (aPiece.x - 0.5));
+    mat3 R = pieceRot(aXf, aTilt);
+    vec3 lp = position * sc;
+    // a piece lying on its side (tilt past ~70°) turns about its middle and rests at its half width
+    vec3 pivot = aTilt.z > 1.2 ? vec3(0.0, uPieceH * 0.5 * sc, 0.0) : vec3(0.0);
+    // growth: the piece scales with its plant from the plant's root (standalone: from the origin), and a
+    // fruit on a plant only sets once the plant is mostly grown (aPiece.w = 1 marks fruit on a plant)
+    float gsc = uGrowth * mix(1.0, smoothstep(0.55, 0.95, uGrowth), aPiece.w);
+    // the piece itself stays isotropic in the world (isoOff); a pile's resting heights are piece units too, a plant's attachment is not
+    vec3 base = vec3(aXf.x, aXf.y * mix(uMean / uScale.y, 1.0, aPiece.w), aXf.z);
+    vec3 pw = aRoot + (isoOff(R * ((lp - pivot) * gsc)) + base - aRoot) * uGrowth;
+    pw += plantDisplace(aXf.xyz, aXf.y, vec2(aPiece.x, 0.4)) * aPiece.w;
+`;
+    const NRM = `
+    vec3 objectNormal = isoNrm(R * normal);
+    #ifdef USE_TANGENT
+    vec3 objectTangent = vec3(tangent.xyz);
+    #endif`;
+    const POS = `
+    vec3 transformed = pw;
+    vSkin = aSkin; vPiece = aPiece.xyz; vLocal = position; vPart = aPart; vCard = aCard;`;
+    const vert = (shader, depth = false) => {
+        for (const k in u)
+            shader.uniforms[k] = u[k];
+        for (const k in own)
+            shader.uniforms[k] = own[k];
+        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 vec3 uUnripe, uRipe, uTint, uStemColor; uniform float uRipeness, uBlemish, uGloss, uSss, uPattern, uPieceH;
+varying vec2 vSkin; varying vec3 vPiece; varying vec3 vLocal; varying vec2 vPart; varying vec2 vCard;
+${LEAF_SDF_GLSL}`)
+            .replace('#include <roughnessmap_fragment>', '#include <roughnessmap_fragment>\n    roughnessFactor = vegRough;')
+            .replace('#include <map_fragment>', `
+    float vegRough = 0.5, vegClear = 0.0, vegHgt = 0.0;
+    float t = vSkin.x, h = vPiece.x;
+    if (vPart.x > 1.5) {
+        // a leaf card (leaf, calyx, crown, tops, husk): cut by its shape, green from the shared leaf colour
+        float lsd = leafSdf(vCard, vPart.y, h);
+        float aa = fwidth(lsd) * 0.9;
+        float cover = 1.0 - smoothstep(-aa, aa, lsd);
+        if (cover < 0.02) discard;
+        vec3 lc = (vPart.x > 3.5 ? vec3(0.95, 0.75, 0.15) : uColor) * (0.8 + 0.4 * vhash11(h * 7.0 + vSkin.y * 3.0));
+        lc *= 1.0 + 0.12 * (1.0 - smoothstep(0.0, 0.05, abs(vCard.x)));
+        diffuseColor.rgb *= lc; diffuseColor.a *= cover * uOpacity;
+        vegRough = 0.6; vegClear = 0.0;
+    } else if (vPart.x > 2.5) {
+        // gills under a cap: dark radial lines
+        float g = 0.5 + 0.5 * sin(atan(vLocal.z, vLocal.x) * 60.0);
+        diffuseColor.rgb *= mix(vec3(0.35, 0.25, 0.18), vec3(0.75, 0.62, 0.45), g) * uTint;
+        vegRough = 0.9; vegClear = 0.0;
+    } else if (vPart.x > 0.5) {
+        // the stem: woody, darker in the grooves
+        diffuseColor.rgb *= uStemColor * (0.8 + 0.3 * vnoise2v(vec2(vSkin.y * 30.0, t * 8.0)));
+        vegRough = 0.9; vegClear = 0.0;
+    } else {
+    float th = atan(vLocal.z, vLocal.x);
+    // ripeness: the knob with a per-piece offset and a top-down gradient (the sun side first); the cursor's warmth ripens locally
+    float ripeLocal = uRipeness + (vPiece.z - 0.5) * 0.35 + 0.15 * (t - 0.5);
+    float ripe = smoothstep(0.3, 0.7, ripeLocal);
+    vec3 skin = mix(uUnripe, uRipe, ripe);
+    float n1 = fbm2v(vec2(th * 2.0 + h * 10.0, t * 6.0));
+    float n2 = vnoise2v(vec2(th * 26.0, t * 52.0) + h * 7.0);
+    int pat = int(uPattern + 0.5);
+    if (pat == 1) { skin = mix(skin, uRipe * 1.2, 0.5 * ripe * smoothstep(0.45, 0.65, fbm2v(vec2(th * 4.0 + h * 10.0, t * 1.5)))); skin = mix(skin, uUnripe * 1.1, (1.0 - ripe) * 0.0 + 0.25 * smoothstep(0.55, 0.75, n1) * (1.0 - t)); }
+    else if (pat == 2) { skin *= 1.0 - 0.1 * smoothstep(0.55, 0.8, n2); }
+    else if (pat == 3) { skin *= 1.0 - 0.3 * smoothstep(0.72, 0.8, vnoise2v(vec2(th * 20.0, t * 40.0) + h)); }
+    else if (pat == 4) { float tip = smoothstep(0.85, 1.0, t) + smoothstep(0.1, 0.0, t); skin = mix(skin, vec3(0.25, 0.15, 0.08), tip * ripe); skin *= 1.0 - 0.15 * smoothstep(0.6, 0.75, n1) * ripe; }
+    else if (pat == 5) { float sd = pow(max(0.0, cos(34.0 * th * 0.5 + t * 22.0) * cos(34.0 * th * 0.5 - t * 22.0)), 4.0); skin = mix(skin, vec3(0.9, 0.8, 0.3), smoothstep(0.3, 0.6, sd)); }
+    else if (pat == 6) { skin = mix(skin, skin * 0.6 + vec3(0.35, 0.35, 0.45), 0.45 * smoothstep(0.4, 0.7, n1)); }
+    else if (pat == 7) { float st = smoothstep(0.35, 0.5, abs(fract(th / 6.2832 * 11.0 + 0.3 * n1) - 0.5)); skin = mix(skin * 0.55, skin * 1.25 + vec3(0.1, 0.15, 0.05), st); }
+    else if (pat == 8) { float la = abs(sin(10.0 * th * 0.5 + t * 14.0) * sin(10.0 * th * 0.5 - t * 14.0)); skin = mix(skin * 0.55, skin, smoothstep(0.05, 0.35, la)); skin = mix(skin, vec3(0.4, 0.5, 0.2), smoothstep(0.7, 0.95, la) * 0.5); }
+    else if (pat == 9) { skin *= 0.75 + 0.35 * smoothstep(0.2, 0.9, 0.5 + 0.5 * cos(12.0 * th)); }
+    else if (pat == 10) { skin *= 0.85 + 0.2 * (0.5 + 0.5 * sin(t * 24.0 * 6.2832)); }
+    else if (pat == 11) { float k = abs(sin(14.0 * th * 0.5)) * abs(sin(t * 30.0 * 3.1416)); skin = mix(skin * 0.7, skin * 1.1, smoothstep(0.1, 0.5, k)); }
+    else if (pat == 12) { skin *= 1.0 - 0.2 * smoothstep(0.6, 0.8, n2); skin = mix(skin, skin * vec3(1.2, 1.15, 0.8), 0.3 * smoothstep(0.5, 0.7, n1)); }
+    else if (pat == 13) { skin = mix(skin * 0.8, skin, n2); }
+    else if (pat == 14) { float eye = pow(vnoise2v(vec2(th * 2.0 + 9.0, t * 3.0 + 4.0 + h)), 8.0) * 10.0; skin = mix(skin, skin * 0.55, smoothstep(0.3, 0.9, eye)); skin *= 0.9 + 0.2 * n2; }
+    else if (pat == 15) { skin *= 0.85 + 0.3 * smoothstep(0.3, 0.7, 0.5 + 0.5 * cos(th * 3.0 + n1 * 4.0)); skin = mix(skin, skin * 0.7, smoothstep(0.85, 1.0, t)); }
+    else if (pat == 16) { // blush: the sun side flushes red over a yellow ground, finely speckled
+        float sunSide = 0.5 + 0.5 * cos(th + h * 6.2832); skin = mix(skin, uRipe * vec3(1.1, 0.55, 0.45), ripe * smoothstep(0.25, 0.9, sunSide + 0.3 * n1 - 0.2) * 0.85); skin *= 0.92 + 0.16 * n2; }
+    else if (pat == 17) { // coconut fibre: hairy brown streaks along the meridians, three dark eyes at the base
+        float fib = fbm2v(vec2(th * 3.0, t * 40.0 + h)); skin *= 0.6 + 0.8 * fib; float eye = smoothstep(0.08, 0.0, length(vec2(fract(th / 6.2832 * 3.0) - 0.5, (t - 0.06) * 4.0)) - 0.1); skin = mix(skin, skin * 0.3, eye * smoothstep(0.15, 0.05, t)); }
+    else if (pat == 18) { // cantaloupe netting: a raised pale net over a green-tan ground
+        float net = 1.0 - abs(2.0 * fbm2v(vec2(th * 4.0, t * 7.0) + h) - 1.0); net = smoothstep(0.75, 0.95, net); skin = mix(skin, vec3(0.86, 0.82, 0.68), net * 0.85); }
+    else if (pat == 19) { // dragon fruit: magenta skin, scale edges fading to green-yellow
+        float la = abs(sin(8.0 * th * 0.5 + t * 14.0) * sin(8.0 * th * 0.5 - t * 14.0)); skin = mix(skin, mix(vec3(0.85, 0.85, 0.3), vec3(0.4, 0.8, 0.35), 0.5), smoothstep(0.55, 0.95, la) * 0.9); }
+    else if (pat == 20) { // turnip: white below, purple shoulders
+        skin = mix(vec3(0.93, 0.9, 0.84), uRipe, smoothstep(0.45, 0.8, t) * ripe); }
+    else if (pat == 21) { // cabbage head: pale veins radiating from the top, waxy bloom
+        float v = 1.0 - smoothstep(0.0, 0.06, abs(fract(th / 6.2832 * 9.0 + 0.3 * n1) - 0.5) - 0.42); skin = mix(skin, skin * vec3(1.25, 1.2, 1.05), v * (1.0 - t * 0.5)); skin = mix(skin, skin * 0.8 + vec3(0.2, 0.2, 0.15), 0.3 * n1); }
+    else if (pat == 22) { // garlic: cloves as vertical segments, papery white with purple streaks
+        float seg = smoothstep(0.0, 0.5, abs(fract(th / 6.2832 * 7.0) - 0.5)); skin *= 0.85 + 0.2 * seg; skin = mix(skin, vec3(0.65, 0.45, 0.6), 0.35 * smoothstep(0.55, 0.8, fbm2v(vec2(th * 1.5, t * 6.0) + h))); }
+    else if (pat == 23) { // leek: white shank into green, vertical fibres
+        skin = mix(vec3(0.93, 0.92, 0.85), vec3(0.35, 0.6, 0.25), smoothstep(0.35, 0.85, t)); skin *= 0.9 + 0.2 * vnoise2v(vec2(th * 14.0, t * 2.0)); }
+    else if (pat == 24) { // asparagus: green spear, purple-tipped scales
+        float sc = smoothstep(0.3, 0.7, 0.5 + 0.5 * sin(t * 50.0 + th * 2.0)); skin = mix(skin, vec3(0.45, 0.25, 0.45), sc * smoothstep(0.6, 1.0, t) * 0.7); skin *= 0.9 + 0.2 * sc; }
+    else if (pat == 25) { // mushroom cap: cream rim to tan centre (t = radial on the cap)
+        skin = mix(uRipe, uUnripe, smoothstep(0.2, 0.9, t)); skin *= 0.9 + 0.2 * n1; }
+    else if (pat == 26) { // fly agaric: red cap with white warts
+        float w = smoothstep(0.6, 0.75, vnoise2v(vec2(th * 5.0, t * 6.0) + h * 3.0)); skin = mix(uRipe * (0.85 + 0.3 * n1), vec3(0.95, 0.92, 0.85), w); }
+    else if (pat == 27) { // pod: the seeds show as paler bulges, a seam along the top
+        float bul = pow(abs(sin(t * 6.0 * 3.1416)), 1.5); skin *= 0.85 + 0.3 * bul; skin = mix(skin, skin * 0.7, 1.0 - smoothstep(0.0, 0.12, abs(th - 3.1416))); }
+    else if (pat == 28) { // sunflower disc: a phyllotaxis of seeds, darker centre
+        float rr = t; float ang = th; float sp = 0.5 + 0.5 * cos(ang * 21.0 + rr * 60.0) * cos(ang * 13.0 - rr * 60.0); skin = mix(skin * 0.6, skin * 1.3, smoothstep(0.3, 0.8, sp)); skin = mix(skin, vec3(0.3, 0.18, 0.08), smoothstep(0.5, 0.0, rr) * 0.5); }
+    // blemishes and the per-piece scatter
+    skin *= 1.0 - uBlemish * 0.5 * smoothstep(0.78, 0.85, vnoise2v(vec2(th * 5.0, t * 9.0) + h * 13.0));
+    skin *= 0.9 + 0.2 * vhash11(h * 4.0);
+    diffuseColor.rgb *= skin * uTint;
+    vegRough = mix(0.75, 0.3, uGloss * mix(0.5, 1.0, ripe));
+    vegClear = uGloss * mix(0.4, 1.0, ripe);
+    // the peel in relief: pores, warts, kernels, ribs and netting as a height field for the bump
+    float relief = 0.0;
+    if (pat == 2) relief = -0.3 * smoothstep(0.45, 0.85, n2) - 0.1 * vnoise2v(vec2(th * 60.0, t * 120.0));
+    else if (pat == 12) relief = 0.8 * smoothstep(0.6, 0.85, n2);
+    else if (pat == 11) relief = 0.5 * abs(sin(14.0 * th * 0.5)) * abs(sin(t * 30.0 * 3.1416));
+    else if (pat == 8) relief = 0.6 * abs(sin(10.0 * th * 0.5 + t * 14.0) * sin(10.0 * th * 0.5 - t * 14.0));
+    else if (pat == 5) relief = -0.8 * pow(max(0.0, cos(34.0 * th * 0.5 + t * 22.0) * cos(34.0 * th * 0.5 - t * 22.0)), 4.0);
+    else if (pat == 14) relief = -0.5 * smoothstep(0.3, 0.9, pow(vnoise2v(vec2(th * 2.0 + 9.0, t * 3.0 + 4.0 + h)), 8.0) * 10.0);
+    else relief = 0.15 * (vnoise2v(vec2(th * 30.0, t * 40.0) + h) - 0.5);
+    vegHgt = relief * 0.003 + 0.0008 * (fbm2v(vec2(th * 6.0, t * 8.0) + h * 3.0) - 0.5);
+    }`)
+            .replace('#include <normal_fragment_maps>', `#include <normal_fragment_maps>
+    {
+        vec3 dpdx = dFdx(-vViewPosition), dpdy = dFdy(-vViewPosition);
+        float dhx = dFdx(vegHgt), dhy = dFdy(vegHgt);
+        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 <clearcoat_normal_fragment_begin>', '#include <clearcoat_normal_fragment_begin>\n    clearcoatNormal = normal;')
+            .replace('#include <lights_physical_fragment>', '#include <lights_physical_fragment>\n    material.clearcoat = saturate(clearcoat * vegClear);')
+            .replace('#include <lights_fragment_end>', `#include <lights_fragment_end>
+    {
+        float back = max(dot(-normal, uSunDirView), 0.0);
+        reflectedLight.indirectDiffuse += diffuseColor.rgb * back * uSss * 0.8;
+    }`);
+    };
+    mat.customProgramCacheKey = () => 'veg-produce';
+    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${LEAF_SDF_GLSL}\nvarying vec2 vPart; varying vec2 vCard; varying vec3 vPiece;`)
+            .replace('#include <map_fragment>', `if (vPart.x > 1.5) { float lsd = leafSdf(vCard, vPart.y, vPiece.x); if (lsd > 0.0) discard; }`);
+    };
+    depth.customProgramCacheKey = () => 'veg-produce-depth';
+    return { material: mat, depth };
+}
+/** Instance buffers for `count` pieces on a geometry. */
+/** Sets a produce material to a kind: colours, pattern, gloss, translucency, fuzz (sheen), stem colour. */
+export function applyKind(mat, P) {
+    const o = mat.userData.uniforms;
+    o.uUnripe.value.set(P.unripe);
+    o.uRipe.value.set(P.ripe);
+    o.uPattern.value = Math.max(0, PATTERNS.indexOf(P.pattern));
+    o.uSss.value = P.sss;
+    o.uStemColor.value.set(P.stem[2]);
+    const fuzz = P.fuzz || 0;
+    if ((mat.sheen > 0) !== (fuzz > 0))
+        mat.needsUpdate = true;
+    mat.sheen = fuzz;
+    mat.sheenRoughness = 0.85;
+    mat.sheenColor.set(P.ripe).lerp(new THREE.Color(1, 1, 1), 0.6);
+}
+export function instancePieces(geo, count) {
+    const g = new THREE.InstancedBufferGeometry();
+    for (const k of ['position', 'normal', 'uv', 'aSkin', 'aPart', 'aCard'])
+        if (geo.attributes[k])
+            g.setAttribute(k, geo.attributes[k]);
+    g.setIndex(geo.index);
+    g.setAttribute('aXf', new THREE.InstancedBufferAttribute(new Float32Array(count * 4), 4));
+    g.setAttribute('aTilt', new THREE.InstancedBufferAttribute(new Float32Array(count * 4), 4));
+    g.setAttribute('aPiece', new THREE.InstancedBufferAttribute(new Float32Array(count * 4), 4));
+    g.setAttribute('aRoot', new THREE.InstancedBufferAttribute(new Float32Array(count * 3), 3));
+    g.instanceCount = count;
+    return g;
+}
+/**
+ * Where the pieces lie: one piece upright at the origin; a pile = pieces on the ground in a disc
+ * (seeded, no two overlapping: rejection sampling with a growing radius), each with a random yaw and
+ * a resting tilt, and a second layer sitting in the hollows when the disc is full.
+ * `size` = a piece's footprint (its width in unit space). Returns [{ x, y, z, yaw, tiltX, tiltZ, tilt, scale }].
+ */
+export function pilePlacement(count, size, rnd, upright, lie, restY) {
+    const out = [];
+    const tiltOf = (layer) => lie ? Math.PI / 2 + (rnd() - 0.5) * 0.3 : (upright ? 0.08 : 0.3) * (0.4 + rnd()) * (layer ? 1.5 : 1);
+    if (count <= 1)
+        return [{ x: 0, y: lie ? restY : 0, z: 0, yaw: rnd() * TAU, tiltX: 1, tiltZ: 0, tilt: lie ? Math.PI / 2 : (upright ? 0 : 0.15), scale: 1 }];
+    if (lie) {
+        // lying pieces: rows side by side (spacing = their width), a loose fan of yaws, a second row behind
+        const w = restY * 2.2, perRow = Math.max(1, Math.floor(0.95 / w)), rows = Math.ceil(count / perRow);
+        const base = rnd() * TAU;
+        for (let n = 0; n < count; n++) {
+            const row = Math.floor(n / perRow), col = n % perRow, inRow = Math.min(perRow, count - row * perRow);
+            const x = (col - (inRow - 1) / 2) * w + (rnd() - 0.5) * w * 0.2, z = (row - (rows - 1) / 2) * size * 0.55 + (rnd() - 0.5) * 0.04;
+            const cz = Math.cos(base), sz = Math.sin(base);
+            out.push({ x: x * cz - z * sz, y: restY + row * restY * 0.6, z: x * sz + z * cz, yaw: base + (rnd() - 0.5) * 0.5, tiltX: 1, tiltZ: 0, tilt: Math.PI / 2 + (rnd() - 0.5) * 0.2, scale: 1 });
+        }
+        return out;
+    }
+    // a sunflower spiral packs the disc without overlaps; when it would spill over the box, the next
+    // layer starts over the hollows (smaller disc, higher up)
+    const step = size * 0.52, rMax = 0.5 - size * 0.42;
+    let layer = 0, i = 0;
+    for (let n = 0; n < count; n++) {
+        let r = step * Math.sqrt(i) * (layer ? 0.75 : 1);
+        if (r > rMax && layer < 3) {
+            layer++;
+            i = 0;
+            r = 0;
+        }
+        const a = i * 2.39996 + layer * 1.3 + (rnd() - 0.5) * 0.3;
+        const jit = (rnd() - 0.5) * size * 0.12;
+        out.push({ x: Math.cos(a) * (r + jit), y: layer * size * 0.62 + (lie ? restY : 0), z: Math.sin(a) * (r + jit), yaw: rnd() * TAU, tiltX: rnd() - 0.5, tiltZ: rnd() - 0.5, tilt: tiltOf(layer), scale: 1 });
+        i++;
+    }
+    return out;
+}
+/** A leaf card layer for leaves / calyx / crown / tops / husk, using the common leaf material. */
+export function leafCards(entries) {
+    const geo = leafGeometry(Math.max(1, entries.length));
+    entries.forEach((e, i) => setLeaf(geo, i, e.pos, e.along, e.normal, e.size, e.hash, 0.5, 1, 0, 0, 0, 0));
+    geo.instanceCount = entries.length;
+    for (const k of ['aPos', 'aQuat', 'aInfoA', 'aInfoB'])
+        geo.attributes[k].needsUpdate = true;
+    unitBounds(geo);
+    return geo;
+}
+// ---------------------------------------------------------------------------- assembling a piece
+/** Merges simple part geometries (position, normal, uv) into one with aSkin / aPart / aCard. */
+function mergeParts(parts) {
+    const pos = [], nrm = [], uv = [], skin = [], part = [], card = [], idx = [];
+    for (const p of parts) {
+        const base = pos.length / 3;
+        const g = p.geo, n = g.attributes.position.count;
+        for (let i = 0; i < n; i++) {
+            pos.push(g.attributes.position.getX(i), g.attributes.position.getY(i), g.attributes.position.getZ(i));
+            nrm.push(g.attributes.normal.getX(i), g.attributes.normal.getY(i), g.attributes.normal.getZ(i));
+            uv.push(g.attributes.uv ? g.attributes.uv.getX(i) : 0, g.attributes.uv ? g.attributes.uv.getY(i) : 0);
+            skin.push(g.attributes.aSkin ? g.attributes.aSkin.getX(i) : (p.t === undefined ? 0.5 : p.t), g.attributes.aSkin ? g.attributes.aSkin.getY(i) : (p.seed || 0));
+            part.push(p.part || 0, p.leafType || 0);
+            card.push(g.attributes.aCard ? g.attributes.aCard.getX(i) : 0, g.attributes.aCard ? g.attributes.aCard.getY(i) : 0);
+        }
+        const ix = g.index ? g.index.array : null;
+        if (ix)
+            for (let i = 0; i < ix.length; i++)
+                idx.push(base + ix[i]);
+        else
+            for (let i = 0; i < n; i++)
+                idx.push(base + i);
+    }
+    const geo = new THREE.BufferGeometry();
+    geo.setAttribute('position', new THREE.Float32BufferAttribute(pos, 3));
+    geo.setAttribute('normal', new THREE.Float32BufferAttribute(nrm, 3));
+    geo.setAttribute('uv', new THREE.Float32BufferAttribute(uv, 2));
+    geo.setAttribute('aSkin', new THREE.Float32BufferAttribute(skin, 2));
+    geo.setAttribute('aPart', new THREE.Float32BufferAttribute(part, 2));
+    geo.setAttribute('aCard', new THREE.Float32BufferAttribute(card, 2));
+    geo.setIndex(idx);
+    return geo;
+}
+/** A leaf card as a real quad in piece space (a 2×2 card scaled and framed), part 2. */
+function cardGeo(pos, along, normal, size, seed) {
+    const y = along.clone().normalize();
+    const z = normal.clone().addScaledVector(y, -normal.dot(y)).normalize();
+    const x = new THREE.Vector3().crossVectors(y, z);
+    const g = new THREE.BufferGeometry();
+    const P = [], N = [], C = [];
+    for (const [cx, cy] of [[-1, -1], [1, -1], [1, 1], [-1, 1]]) {
+        const p = pos.clone().addScaledVector(x, cx * size).addScaledVector(y, (cy + 1) * size);
+        P.push(p.x, p.y, p.z);
+        N.push(z.x, z.y, z.z);
+        C.push(cx, cy);
+    }
+    g.setAttribute('position', new THREE.Float32BufferAttribute(P, 3));
+    g.setAttribute('normal', new THREE.Float32BufferAttribute(N, 3));
+    g.setAttribute('aCard', new THREE.Float32BufferAttribute(C, 2));
+    g.setIndex([0, 1, 2, 0, 2, 3]);
+    return { geo: g, part: 2, seed };
+}
+function stemGeo(from, dir, len, rad, bend, seg = 3) {
+    const g = new THREE.CylinderGeometry(rad * 0.7, rad, len, 7, seg || 3, false);
+    g.translate(0, len / 2, 0);
+    const p = g.attributes.position;
+    for (let i = 0; i < p.count; i++) {
+        const t = p.getY(i) / len;
+        p.setX(i, p.getX(i) + (bend || 0) * t * t * len);
+    }
+    g.computeVertexNormals();
+    const q = new THREE.Quaternion().setFromUnitVectors(new THREE.Vector3(0, 1, 0), dir.clone().normalize());
+    g.applyQuaternion(q);
+    g.translate(from.x, from.y, from.z);
+    return { geo: g, part: 1, t: 2 };
+}
+function sphereAt(c, r, sx, sy, sz, detail) {
+    const g = new THREE.SphereGeometry(r, 10 * detail | 0, 7 * detail | 0);
+    g.scale(sx || 1, sy || 1, sz || 1);
+    g.translate(c.x, c.y, c.z);
+    return g;
+}
+/**
+ * One complete piece of a kind in piece space (sits on y = 0, roughly unit tall or wide):
+ * the body (or cluster), its stem, and any leaf / calyx / crown / tops / husk cards.
+ * Returns { geo, height, width } (width = footprint).
+ */
+export function buildPiece(kind, seed, detail) {
+    const P = PRODUCE[kind];
+    const rnd = mulberry32(seed * 7919 + 13);
+    const parts = [];
+    const up = new THREE.Vector3(0, 1, 0);
+    const d = detail || 1;
+    let height = P.h, width = 1;
+    if (P.cluster) {
+        // grapes: spheroids packed in a hanging cone, the stalk above
+        const C = P.cluster, cs = [];
+        for (let i = 0; i < C.n; i++) {
+            const t = Math.pow(rnd(), 0.7); // more near the top
+            const r = C.cone * (1 - t * 0.85) * 0.85 * Math.sqrt(rnd());
+            const a = rnd() * TAU;
+            const c = new THREE.Vector3(Math.cos(a) * r, 0.12 + t * 0.8, Math.sin(a) * r);
+            // settle against neighbours
+            for (let k = 0; k < 2; k++)
+                for (const o of cs) {
+                    const dd = c.distanceTo(o);
+                    if (dd < C.rad * 1.7)
+                        c.addScaledVector(c.clone().sub(o).normalize(), (C.rad * 1.7 - dd) * 0.5);
+                }
+            cs.push(c);
+        }
+        cs.sort((a, b) => b.y - a.y);
+        for (const c of cs) {
+            const g = sphereAt(c, C.rad * (0.85 + 0.3 * rnd()), 1, 1.05, 1, d);
+            const sk = new Float32Array(g.attributes.position.count * 2);
+            for (let i = 0; i < sk.length; i += 2) {
+                sk[i] = c.y;
+                sk[i + 1] = rnd();
+            }
+            g.setAttribute('aSkin', new THREE.Float32BufferAttribute(sk, 2));
+            parts.push({ geo: g, part: 0 });
+        }
+        if (P.stem[0] > 0)
+            parts.push(stemGeo(new THREE.Vector3(0, 0.9, 0), up, P.stem[0], P.stem[1], 0.3));
+        width = C.cone * 2;
+        height = 1.1;
+    }
+    else if (P.mushroom) {
+        // a mushroom: a thick stem, a cap (a flattened dome, rim curled under), gills as a dark underside disc
+        const M = P.mushroom;
+        parts.push(stemGeo(new THREE.Vector3(0, 0, 0), up, M.stemH, M.stemR, 0.15 * (rnd() - 0.5), 5));
+        const cap = new THREE.SphereGeometry(1, 28 * d | 0, 16 * d | 0, 0, TAU, 0, Math.PI * 0.62);
+        cap.scale(M.capR, M.capH, M.capR);
+        cap.translate(0, M.stemH - M.capH * 0.35, 0);
+        const cp = cap.attributes.position;
+        for (let i = 0; i < cp.count; i++) {
+            const x = cp.getX(i), z = cp.getZ(i), r = Math.hypot(x, z);
+            const bump = 1 + 0.03 * Math.sin(Math.atan2(z, x) * 9 + r * 20);
+            cp.setX(i, x * bump);
+            cp.setZ(i, z * bump);
+        }
+        cap.computeVertexNormals();
+        const skc = new Float32Array(cp.count * 2);
+        for (let i = 0; i < cp.count; i++) {
+            skc[i * 2] = Math.min(1, Math.hypot(cp.getX(i), cp.getZ(i)) / M.capR);
+            skc[i * 2 + 1] = rnd();
+        }
+        cap.setAttribute('aSkin', new THREE.Float32BufferAttribute(skc, 2));
+        parts.push({ geo: cap, part: 0 });
+        const gills = new THREE.CircleGeometry(M.capR * 0.95, 28 * d | 0);
+        gills.rotateX(Math.PI / 2);
+        gills.translate(0, M.stemH - M.capH * 0.2, 0);
+        parts.push({ geo: gills, part: 3, t: 0.5 });
+        width = M.capR * 2;
+        height = M.stemH + M.capH * 0.7;
+    }
+    else if (P.florets) {
+        // broccoli: a thick stalk forking into a dome of florets
+        const F = P.florets;
+        parts.push(stemGeo(new THREE.Vector3(0, 0, 0), up, P.stem[0], P.stem[1], 0, 4));
+        for (let i = 0; i < 6; i++) {
+            const a = i / 6 * TAU;
+            parts.push(stemGeo(new THREE.Vector3(0, P.stem[0] * 0.8, 0), new THREE.Vector3(Math.cos(a) * 0.5, 1, Math.sin(a) * 0.5), 0.3, P.stem[1] * 0.4, 0, 2));
+        }
+        for (let i = 0; i < F.n; i++) {
+            const u = rnd(), v = rnd();
+            const th = Math.acos(1 - u * 0.75), ph = v * TAU; // the top of a sphere
+            const c = new THREE.Vector3(Math.sin(th) * Math.cos(ph) * F.dome, 0.5 + Math.cos(th) * F.dome * 0.9, Math.sin(th) * Math.sin(ph) * F.dome);
+            const g = sphereAt(c, F.rad * (0.7 + 0.6 * rnd()), 1, 0.8, 1, d * 0.8);
+            const sk = new Float32Array(g.attributes.position.count * 2);
+            for (let k = 0; k < sk.length; k += 2) {
+                sk[k] = 0.5 + c.y * 0.3;
+                sk[k + 1] = rnd();
+            }
+            g.setAttribute('aSkin', new THREE.Float32BufferAttribute(sk, 2));
+            parts.push({ geo: g, part: 0 });
+        }
+        width = F.dome * 2.2;
+        height = 0.95;
+    }
+    else {
+        const body = produceBody(kind, seed, d);
+        let bodies = [body];
+        if (P.pairs) {
+            const b2 = produceBody(kind, seed + 1, d);
+            body.geo.translate(-0.42, 0, 0);
+            b2.geo.translate(0.42, 0, 0.1);
+            bodies = [body, b2];
+            parts.push(stemGeo(new THREE.Vector3(-0.42, P.h * 0.98, 0), new THREE.Vector3(0.45, 1, 0), P.stem[0], P.stem[1], -0.2));
+            parts.push(stemGeo(new THREE.Vector3(0.42, P.h * 0.98, 0.1), new THREE.Vector3(-0.45, 1, -0.1), P.stem[0], P.stem[1], 0.2));
+            width = 1.6;
+        }
+        for (const b of bodies)
+            parts.push({ geo: b.geo, part: 0 });
+        width = Math.max(width, body.width);
+        if (P.invert) {
+            for (const p of parts) {
+                p.geo.rotateX(Math.PI);
+                p.geo.translate(0, P.h, 0);
+            }
+        }
+        const top = P.invert ? new THREE.Vector3(body.bottom.x, P.h - body.bottom.y, body.bottom.z) : body.top;
+        if (!P.pairs && P.stem[0] > 0)
+            parts.push(stemGeo(top.clone().add(new THREE.Vector3(0, -0.01, 0)), new THREE.Vector3(0.15 * (rnd() - 0.5), 1, 0.15 * (rnd() - 0.5)), P.stem[0], P.stem[1], 0.3 * (rnd() - 0.5)));
+        const stemTop = top.clone().add(new THREE.Vector3(0, P.stem[0] * 0.9, 0));
+        if (P.leaf)
+            parts.push(Object.assign(cardGeo(stemTop, new THREE.Vector3(0.7, 0.5, 0.2).normalize(), new THREE.Vector3(0.2, 1, 0.3), 0.16, rnd()), { leafType: LEAF_TYPES.indexOf('broadleaf') }));
+        if (P.calyx)
+            for (let i = 0; i < P.calyx; i++) {
+                const a = i / P.calyx * TAU + rnd() * 0.4;
+                // sepals: spreading (tomato), flat and broad (persimmon) or a standing crown (pomegranate)
+                const along = P.calyxUp ? new THREE.Vector3(Math.cos(a) * 0.5, 1, Math.sin(a) * 0.5) : new THREE.Vector3(Math.cos(a), P.calyxFlat ? -0.05 : 0.15, Math.sin(a));
+                const nrm = P.calyxUp ? new THREE.Vector3(Math.cos(a), 0.3, Math.sin(a)) : up.clone();
+                parts.push(Object.assign(cardGeo(top.clone().add(new THREE.Vector3(0, -0.01, 0)), along, nrm, (P.calyxFlat ? 0.17 : P.calyxUp ? 0.09 : 0.11) + 0.04 * rnd(), rnd()), { leafType: LEAF_TYPES.indexOf(P.calyxFlat ? 'round' : 'lanceolate') }));
+            }
+        // wrapper leaves (cabbage, cauliflower): big round leaves cupped around the head from the base
+        if (P.wrap)
+            for (let i = 0; i < P.wrap; i++) {
+                const a = i / P.wrap * TAU + rnd() * 0.5, r = body.width * 0.42;
+                parts.push(Object.assign(cardGeo(new THREE.Vector3(Math.cos(a) * r, 0.04, Math.sin(a) * r), new THREE.Vector3(Math.cos(a) * 0.55, 1, Math.sin(a) * 0.55), new THREE.Vector3(Math.cos(a), -0.25, Math.sin(a)), 0.2 + 0.06 * rnd(), rnd()), { leafType: LEAF_TYPES.indexOf('round') }));
+            }
+        // dragon fruit: scale tips sticking out over the body
+        if (P.scaleTips)
+            for (let i = 0; i < P.scaleTips; i++) {
+                const a = i * 2.4 + rnd() * 0.3, tt = 0.15 + 0.75 * (i / P.scaleTips);
+                const r = body.width * 0.5 * 0.92 * Math.pow(Math.sin(Math.PI * tt), 0.5);
+                const c = new THREE.Vector3(Math.cos(a) * r, tt * P.h, Math.sin(a) * r);
+                parts.push(Object.assign(cardGeo(c, new THREE.Vector3(Math.cos(a) * 0.5, 1, Math.sin(a) * 0.5), new THREE.Vector3(Math.cos(a), 0.2, Math.sin(a)), 0.09 + 0.04 * rnd(), rnd()), { leafType: LEAF_TYPES.indexOf('lanceolate') }));
+            }
+        // wheat: awns, long thin blades fanning from the head
+        if (P.awns)
+            for (let i = 0; i < 14; i++) {
+                const a = i / 14 * TAU, tt = 0.3 + 0.65 * rnd();
+                parts.push(Object.assign(cardGeo(new THREE.Vector3(Math.cos(a) * 0.06, tt, Math.sin(a) * 0.06), new THREE.Vector3(Math.cos(a) * 0.25, 1, Math.sin(a) * 0.25), new THREE.Vector3(Math.cos(a), 0, Math.sin(a)), 0.25, rnd()), { leafType: LEAF_TYPES.indexOf('blade') }));
+            }
+        // sunflower: ray florets around the disc
+        if (P.rays)
+            for (let i = 0; i < P.rays; i++) {
+                const a = i / P.rays * TAU + rnd() * 0.1, r = body.width * 0.47;
+                parts.push(Object.assign(cardGeo(new THREE.Vector3(Math.cos(a) * r, P.h * 0.8, Math.sin(a) * r), new THREE.Vector3(Math.cos(a), 0.1 + 0.2 * rnd(), Math.sin(a)), up, 0.19 + 0.04 * rnd(), rnd()), { leafType: LEAF_TYPES.indexOf('petal'), part: 4 }));
+            }
+        if (P.crown)
+            for (let i = 0; i < P.crown; i++) {
+                const a = i / P.crown * TAU + rnd() * 0.5, r = 0.05 + 0.06 * rnd();
+                parts.push(Object.assign(cardGeo(top.clone().add(new THREE.Vector3(Math.cos(a) * r, 0, Math.sin(a) * r)), new THREE.Vector3(Math.cos(a) * (0.3 + 0.5 * rnd()), 1, Math.sin(a) * (0.3 + 0.5 * rnd())), new THREE.Vector3(Math.cos(a), 0.2, Math.sin(a)), 0.2 + 0.12 * rnd(), rnd()), { leafType: LEAF_TYPES.indexOf('blade') }));
+                height = P.h + 0.5;
+            }
+        if (P.tops)
+            for (let i = 0; i < P.tops; i++) {
+                const a = i / P.tops * TAU + rnd() * 0.5;
+                parts.push(Object.assign(cardGeo(top.clone(), new THREE.Vector3(Math.cos(a) * (0.25 + 0.3 * rnd()), 1, Math.sin(a) * (0.25 + 0.3 * rnd())), new THREE.Vector3(Math.cos(a), 0.3, Math.sin(a)), (P.topsBlade ? 0.3 : 0.16) + 0.1 * rnd(), rnd()), { leafType: LEAF_TYPES.indexOf(P.topsBlade ? 'blade' : (kind === 'radish' || kind === 'beet' || kind === 'turnip') ? 'round' : 'frond') }));
+                height = P.h + 0.4;
+            }
+        if (P.husk)
+            for (let i = 0; i < P.husk; i++) {
+                const a = i / P.husk * TAU + rnd() * 0.3, r = body.width * 0.55;
+                parts.push(Object.assign(cardGeo(new THREE.Vector3(Math.cos(a) * r * 0.6, 0.02, Math.sin(a) * r * 0.6), new THREE.Vector3(Math.cos(a) * (0.35 + 0.15 * rnd()), 1, Math.sin(a) * (0.35 + 0.15 * rnd())), new THREE.Vector3(Math.cos(a), 0.1, Math.sin(a)), 0.42 + 0.08 * rnd(), rnd()), { leafType: LEAF_TYPES.indexOf('blade') }));
+            }
+        if (P.roots)
+            for (let i = 0; i < 8; i++) {
+                const a = rnd() * TAU;
+                parts.push(stemGeo(new THREE.Vector3(Math.cos(a) * 0.05, 0.02, Math.sin(a) * 0.05), new THREE.Vector3(Math.cos(a) * 0.6, -0.5, Math.sin(a) * 0.6), 0.1 + 0.06 * rnd(), 0.006, 0, 1));
+            }
+    }
+    const geo = mergeParts(parts);
+    for (const p of parts)
+        p.geo.dispose();
+    return { geo, height, width };
+}