@3driseai/3drise-viewer 0.1.41 → 0.1.43

package/dist/components/vegetation/useVegetationInstance.d.ts

@@ -0,0 +1,39 @@
+import { type RefObject } from 'react';
+import * as THREE from 'three';
+import type { AnimationOptions, MouseMoveDomain } from '@3driseai/3drise-core';
+import type { ObjectReadyProps } from '../../types/objectReady';
+export interface VegetationInstance {
+    object: THREE.Object3D;
+    materials: THREE.Material[];
+    apply(cfg: Record<string, unknown>): void;
+    /** Per frame. The renderer is for the impostor bake (detail levels); variants without one ignore it. */
+    update(dt: number, camera: THREE.Camera, sunWorld: THREE.Vector3, renderer?: THREE.WebGLRenderer): void;
+    dispose(): void;
+}
+export interface VegetationVariantProps extends ObjectReadyProps {
+    config: {
+        type: string;
+    };
+    /** Scene object id: the live-edit handle is found by it. */
+    id?: string;
+    /** Keyframes on the config knobs (animations.vegetation.animations). */
+    keyframes?: AnimationOptions[];
+    /** Pointer bindings on the config knobs (mouseMove.vegetation). */
+    mouseMove?: MouseMoveDomain;
+}
+export interface VegetationCore {
+    DEFAULTS: Record<string, unknown>;
+    STRUCTURAL: readonly string[];
+    ANIMATABLE: ReadonlySet<string>;
+    createUniforms(): Record<string, {
+        value: any;
+    }>;
+    build(u: Record<string, {
+        value: any;
+    }>, cfg: Record<string, unknown>): VegetationInstance;
+}
+export declare function useVegetationInstance(core: VegetationCore, props: VegetationVariantProps): {
+    rootRef: RefObject<THREE.Group | null>;
+    instance: VegetationInstance;
+};
+//# sourceMappingURL=useVegetationInstance.d.ts.map

package/dist/components/vegetation/useVegetationInstance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useVegetationInstance.d.ts","sourceRoot":"","sources":["../../../src/components/vegetation/useVegetationInstance.ts"],"names":[],"mappings":"AAkBA,OAAO,EAA4D,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AACjG,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAK/E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE,MAAM,WAAW,kBAAkB;IAC/B,MAAM,EAAE,KAAK,CAAC,QAAQ,CAAC;IACvB,SAAS,EAAE,KAAK,CAAC,QAAQ,EAAE,CAAC;IAC5B,KAAK,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAC1C,wGAAwG;IACxG,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,MAAM,EAAE,QAAQ,EAAE,KAAK,CAAC,OAAO,EAAE,QAAQ,CAAC,EAAE,KAAK,CAAC,aAAa,GAAG,IAAI,CAAC;IACxG,OAAO,IAAI,IAAI,CAAC;CACnB;AAED,MAAM,WAAW,sBAAuB,SAAQ,gBAAgB;IAC5D,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IACzB,4DAA4D;IAC5D,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,wEAAwE;IACxE,SAAS,CAAC,EAAE,gBAAgB,EAAE,CAAC;IAC/B,mEAAmE;IACnE,SAAS,CAAC,EAAE,eAAe,CAAC;CAC/B;AAED,MAAM,WAAW,cAAc;IAC3B,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IAC9B,UAAU,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAChC,cAAc,IAAI,MAAM,CAAC,MAAM,EAAE;QAAE,KAAK,EAAE,GAAG,CAAA;KAAE,CAAC,CAAC;IACjD,KAAK,CAAC,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,KAAK,EAAE,GAAG,CAAA;KAAE,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,kBAAkB,CAAC;CAC9F;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,cAAc,EAAE,KAAK,EAAE,sBAAsB,GAAG;IAAE,OAAO,EAAE,SAAS,CAAC,KAAK,CAAC,KAAK,GAAG,IAAI,CAAC,CAAC;IAAC,QAAQ,EAAE,kBAAkB,CAAA;CAAE,CAwBnK"}

package/dist/components/vegetation/useVegetationInstance.js

@@ -0,0 +1,45 @@
+// =============================================================================
+// useVegetationInstance — the React side every vegetation component shares
+// =============================================================================
+//
+// A variant's core (vegetation/core/<key>.ts, emitted from the lab module) is plain three.js:
+// createUniforms(), build(u, cfg) -> { object, apply, update, dispose }. This hook wires it into
+// the config pattern:
+//
+//   - base config over the type's defaults (withConfigDefaults);
+//   - built once; a change of a STRUCTURAL knob rebuilds (dispose + build, the uniforms outlive
+//     it so phases and keyframes survive); every other committed change and every per-frame
+//     override goes through instance.apply (the one door: live drag, keyframes, pointer
+//     bindings, timeline clips — useConfigDriver);
+//   - the scene sun (useCloudSun) for the leaves' translucency only — the plants are lit by the
+//     scene's lights like any mesh;
+//   - the renderer, for the impostor bake of the detail levels (tree, bush, hedge);
+//   - readiness (useObjectReady) and disposal.
+//
+import { useCallback, useEffect, useLayoutEffect, useMemo, useRef } from 'react';
+import { useFrame } from '@react-three/fiber';
+import { withConfigDefaults } from '../../utils/configAnimations.js';
+import { useObjectReady } from '../../hooks/useObjectReady.js';
+import { useConfigDriver } from '../../hooks/useConfigDriver.js';
+import { useCloudSun } from '../../hooks/useCloudSun.js';
+export function useVegetationInstance(core, props) {
+    const { config, id, keyframes, mouseMove, onObjectReady, onObjectDispose } = props;
+    const rootRef = useRef(null);
+    useObjectReady(rootRef, config, onObjectReady, onObjectDispose);
+    const cfg = useMemo(() => withConfigDefaults(core.DEFAULTS, config), [config]); // eslint-disable-line react-hooks/exhaustive-deps
+    // uniforms outlive rebuilds, so phases and keyframes survive a structural change
+    const uniforms = useMemo(() => core.createUniforms(), []); // eslint-disable-line react-hooks/exhaustive-deps
+    const structuralKey = JSON.stringify(core.STRUCTURAL.map((k) => cfg[k]));
+    const instance = useMemo(() => core.build(uniforms, cfg), [uniforms, structuralKey]); // eslint-disable-line react-hooks/exhaustive-deps
+    useEffect(() => () => instance.dispose(), [instance]);
+    useLayoutEffect(() => { instance.apply(cfg); }, [instance, cfg]);
+    const push = useCallback((merged) => { instance.apply(merged); }, [instance]);
+    useConfigDriver({ rootRef, id, family: 'vegetation', base: cfg, structural: core.STRUCTURAL, allowed: core.ANIMATABLE, keyframes, mouseMove, push });
+    // the scene's sun, read-only: only the translucency of the leaves looks at it
+    const sun = useCloudSun();
+    useFrame((state, delta) => {
+        const s = sun.update();
+        instance.update(Math.min(delta, 0.1), state.camera, s.direction, state.gl);
+    });
+    return { rootRef, instance };
+}

package/dist/components/vegetation/vegetationCore.d.ts

@@ -0,0 +1,412 @@
+import * as THREE from 'three';
+export declare const DEG_V: number;
+export declare const WIND_MS_VEG = 8;
+export declare function mulberry32(a: any): () => number;
+export declare function setColor(uniform: any, v: any): void;
+/** Uniforms every vegetation object has (shared by all of its materials). */
+export declare function createCommonUniforms(): {
+    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;
+    };
+};
+/** The base knobs every vegetation object shares (push point, part 1). */
+export declare function applyCommonConfig(u: any, c: any): void;
+export declare const _vs: THREE.Vector3, _vq: THREE.Quaternion, _vsun: THREE.Vector3, _vm: THREE.Matrix3;
+/** Per-frame bookkeeping shared by every object: scale, integrated phases, sun into view space. */
+export declare function updateCommon(u: any, object: any, camera: any, dt: any, sunWorld: any): void;
+export declare const LEAF_TYPES: string[];
+export declare const VEG_UNIFORMS_GLSL = "\nuniform float uTime, uWindPhase, uWindStrength, uTurb, uSpeed, uSway, uFlutter, uOpacity, uSeason, uFoliage, uLeafType, uLeafSize, uGrowth;\nuniform float uMean;\nuniform vec2 uWindDir;\nuniform vec3 uScale, uColor, uShadeColor, uSunDirView;\nuniform vec3 uViewPos; uniform float uLodK, uLodOrtho, uLodBias, uImpReady, uBake; uniform mat3 uBakeView; uniform vec2 uBakeDepth;\n// The plant's skeleton follows the (possibly non-uniform) transform scale; its local shapes (cards,\n// fruit, blade widths, bark rings) must not: an offset in \"mean-scale units\" is divided back per axis\n// so it stays isotropic in the world, and its normal is pre-multiplied by the scale so the normal\n// matrix (which undoes the scale) lands on the isotropic normal.\nvec3 isoOff(vec3 o) { return o * uMean / uScale; }\nvec3 isoNrm(vec3 n) { return normalize(n * uScale); }\n";
+export declare const NOISE_GLSL_V = "\nfloat vhash12(vec2 p) { vec3 q = fract(vec3(p.xyx) * 0.1031); q += dot(q, q.yzx + 33.33); return fract((q.x + q.y) * q.z); }\nfloat vhash11(float p) { p = fract(p * 0.1031); p *= p + 33.33; p *= p + p; return fract(p); }\nfloat vnoise2v(vec2 p) {\n    vec2 i = floor(p); vec2 f = fract(p); f = f * f * (3.0 - 2.0 * f);\n    return mix(mix(vhash12(i), vhash12(i + vec2(1, 0)), f.x), mix(vhash12(i + vec2(0, 1)), vhash12(i + vec2(1, 1)), f.x), f.y);\n}\nfloat fbm2v(vec2 p) { return (0.5 * vnoise2v(p) + 0.25 * vnoise2v(p * 2.03 + 7.1) + 0.125 * vnoise2v(p * 4.07 + 3.3)) / 0.875; }\nfloat vbump(float x) { float t = clamp(1.0 - x * x, 0.0, 1.0); return t * t; }\nvec3 qrot(vec4 q, vec3 v) { return v + 2.0 * cross(q.xyz, cross(q.xyz, v) + q.w * v); }\n";
+/**
+ * The wind as one displacement field over the plant (unit space).
+ *   gust      low-frequency noise travelling downwind (uWindPhase), sharpened by turbulence into
+ *             separate gust fronts, so the whole plant leans and recovers rather than oscillating.
+ *   bend      the plant leans with the gust, ∝ height² (a cantilever), losing a little height.
+ *   sway      each branch oscillates at its own frequency and phase (w.x) with its own flexibility
+ *             (w.y), driven by the gust strength; sideways component so tips draw ellipses.
+ * w = (phase, flexibility). hf = height fraction of the attachment (0 ground, 1 top).
+ */
+export declare const WIND_GLSL = "\n#ifndef VEG_M\n#define VEG_M modelMatrix\n#endif\nfloat gustAt(vec2 xz) {\n    // metres: the point inside the plant plus where the plant stands (modelMatrix), so gust fronts\n    // travel across a group of plants and copies of one plant (layouts) do not sway in lockstep\n    vec2 q = (xz * uScale.xz + VEG_M[3].xz) * 0.06 - uWindDir * uWindPhase * 0.08;\n    float g = vnoise2v(q) * 0.65 + vnoise2v(q * 3.1 + uTime * 0.15) * 0.35;\n    g = mix(g, smoothstep(0.35, 0.75, g), uTurb);\n    return 0.25 + 1.5 * g;\n}\nvec3 plantDisplace(vec3 p, float hf, vec2 w) {\n    float W = uWindStrength * gustAt(p.xz);\n    float h2 = hf * hf;\n    // cantilever lean: a quarter of the height in a full gale on a flexible plant\n    vec2 lean = uWindDir * W * 0.25 * h2 * uSway;\n    // branch sway: own frequency and phase, elliptical tip path\n    float f = 1.3 + 1.6 * w.y;\n    float s = sin(uTime * f + w.x * 6.2832) * W * w.y * 0.08 * uSway * hf;\n    float c = cos(uTime * f * 0.71 + w.x * 4.1) * W * w.y * 0.03 * uSway * hf;\n    vec3 d = vec3(lean.x, -0.35 * length(lean) * hf, lean.y);\n    d += vec3(uWindDir.x * s - uWindDir.y * c, 0.25 * abs(s), uWindDir.y * s + uWindDir.x * c);\n    return d;\n}\n";
+/**
+ * Leaf shape as a signed distance in card space (x across, y along, base at y = -1, tip at y = 1),
+ * for every leaf type. Positive = outside. Anti-aliased by the caller with fwidth.
+ */
+export declare const LEAF_SDF_GLSL = "\n// serrated margin: small teeth along the edge, finer toward the tip\nfloat teeth(float t, float k, float amp) { return amp * abs(sin(t * k * 3.1416)) * (1.0 - 0.5 * t); }\nfloat leafSdf(vec2 p, float type, float h) {\n    float t = (p.y + 1.0) * 0.5;          // 0 base .. 1 tip\n    // asymmetry: one half a little wider, the midrib slightly bowed\n    float asym = 1.0 + 0.1 * (h - 0.5) * sign(p.x);\n    float ax = abs(p.x - 0.06 * (h - 0.5) * sin(3.1416 * t));\n    if (type < 0.5) {            // broadleaf: ovate, pointed drip tip, fine serration\n        float w = (0.62 * pow(sin(3.1416 * clamp(t, 0.0, 1.0)), 0.7) * (1.0 - 0.25 * t) + 0.02 * (1.0 - t)) * asym;\n        w -= teeth(t, 14.0 + 6.0 * h, 0.025);\n        return max(ax - w, -p.y - 1.0);\n    } else if (type < 1.5) {     // lobed (oak): rounded lobes with deep sinuses\n        float lob = 0.5 + 0.5 * cos(3.1416 * (t * 7.0 + 0.5 + 0.4 * h));\n        lob = smoothstep(0.0, 1.0, lob);\n        float w = (0.3 + 0.36 * lob) * pow(sin(3.1416 * clamp(t, 0.02, 1.0)), 0.45) * asym;\n        return max(max(ax - w, -p.y - 1.0), p.y - 1.0);\n    } else if (type < 2.5) {     // needles: a tuft fanning from the base\n        float d = 1e3;\n        for (int i = 0; i < 7; i++) {\n            float a = (float(i) - 3.0) * 0.21 + 0.1 * (h - 0.5);\n            vec2 dir = vec2(sin(a), cos(a));\n            vec2 q = p - vec2(0.0, -1.0);\n            float s = clamp(dot(q, dir), 0.0, 1.9 - 0.15 * abs(float(i) - 3.0));\n            d = min(d, length(q - dir * s) - 0.035);\n        }\n        return d;\n    } else if (type < 3.5) {     // round (box, privet): obovate with a notch at the tip\n        float w = 0.68 * pow(sin(3.1416 * clamp(t, 0.0, 1.0)), 0.55) * (0.85 + 0.3 * t) * asym;\n        float notch = smoothstep(0.08, 0.0, ax) * smoothstep(0.9, 1.0, t) * 0.12;\n        return max(ax - w, -p.y - 1.0 + 0.0) + notch;\n    } else if (type < 4.5) {     // lanceolate (willow): long, narrow, finely toothed\n        float w = 0.2 * pow(sin(3.1416 * clamp(t, 0.0, 1.0)), 0.55) * asym - teeth(t, 22.0, 0.012);\n        return max(ax - w, -p.y - 1.0);\n    } else if (type < 5.5) {     // frond: a rachis with leaflets\n        float rachis = ax - 0.04;\n        float seg = fract(t * 9.0 + 0.5) - 0.5;\n        float leaflet = max(abs(seg) - 0.28 * (1.0 - t * 0.6), ax - 0.95 * (1.0 - t * 0.85) * smoothstep(0.0, 0.05, t));\n        return max(min(rachis, leaflet), -p.y - 1.0);\n    } else if (type < 6.5) {     // ivy: three to five lobes, cordate base\n        vec2 q = vec2(ax, p.y + 0.15);\n        float c = length(q - vec2(0.0, 0.1)) - 0.75;\n        float side = length(q - vec2(0.55, -0.25)) - 0.5;\n        float tip = max(ax * 1.6 - (1.0 - p.y) * 0.9, -p.y - 0.5);\n        float base = -(length(q - vec2(0.0, -0.95)) - 0.25);   // the notch at the stalk\n        return max(min(min(c, side), tip), base);\n    } else if (type < 7.5) {     // petal: a soft drop, widest near the tip, a wavy edge\n        float w = 0.55 * pow(sin(3.1416 * clamp(t, 0.0, 1.0)), 0.5) * (0.55 + 0.45 * t) * asym;\n        w += 0.03 * sin(t * 19.0 + h * 7.0) * t;\n        return max(ax - w, -p.y - 1.0);\n    } else if (type < 8.5) {     // blade (grass): tapering strip\n        return max(ax - 0.12 * (1.0 - t * 0.9), -p.y - 1.0);\n    }\n    // maple: palmate, five pointed lobes from the base\n    vec2 q = p - vec2(0.0, -0.75);\n    float r = length(q), a = atan(q.x, q.y);\n    float lobes = 0.55 + 0.55 * pow(abs(cos(a * 2.5)), 0.35) * (1.0 - 0.35 * abs(a) / 3.1416);\n    float lim = smoothstep(2.6, 1.9, abs(a));\n    return r - 1.55 * lobes * lim * (1.0 - 0.1 * h);\n}\n";
+/**
+ * Distance detail for a plant and every copy of it (layout mirrors, linked instances). One quantity
+ * decides, s: the plant's bounding radius over the camera's half-height at its distance (≈ the share of
+ * half the screen it fills). The CPU (per draw: onBeforeRender / onBeforeShadow, from the drawn mesh's
+ * own matrixWorld, so each mirror decides for itself) and the GPU (vertex, from modelMatrix) evaluate
+ * the same s from the same shared uniforms (uViewPos / uLodK = the main camera, set in updateCommon).
+ *   s > FULL               every leaf, curled cards, every branch level
+ *   FLAT..FULL             the leaf count falls toward MIN, the cards grow (1/√share, ≤ GROW) so the cover holds
+ *   s < FLAT               flat cards (2 triangles instead of 16), the finest branch level dropped
+ *   IMP·0.8 .. IMP·1.2     dithered cross-fade to the impostor (both drawn, complementary pixels)
+ *   s < IMP·0.8            the impostor alone: one octahedral-impostor card
+ * Shadow pass: flat cards, SHADOW × the leaves, trunk + first branch level; the impostor casts below IMP.
+ */
+export declare const LOD: {
+    FULL: number;
+    FLAT: number;
+    IMP: number;
+    MIN: number;
+    SHADOW: number;
+    GROW: number;
+    FADE_IN: number;
+    FADE_OUT: number;
+};
+export declare const LOD_GLSL_V: string;
+/** Interleaved gradient noise: the dither of the cross-fade (full detail keeps the pixels the impostor leaves). */
+export declare const LOD_GLSL_F = "\nfloat vegIgn(vec2 p) { return fract(52.9829189 * fract(dot(p, vec2(0.06711056, 0.00583715)))); }\n";
+/**
+ * Bark: a lit material whose vertices follow the wind (aWind = hf, phase, flex; aRing = angle 0..1,
+ * length along the branch in metres-at-scale-1) and whose surface is procedural bark: vertical ridges
+ * (anisotropic fbm), fissures darkening with depth, lichen specks on the shaded side, as a bump map.
+ */
+export declare function barkMaterial(u: any, opts: any): {
+    material: THREE.MeshStandardMaterial;
+    depth: THREE.MeshDepthMaterial;
+};
+/**
+ * Leaf cards: one instanced draw. Per instance: aPos (attachment, unit space), aQuat (card frame:
+ * card x across, y along, z = normal), aInfoA = (size, hash, hf, ao), aInfoB = (phase, flex, order, kind).
+ * The card is a 2×2 quad; `uFoliage` keeps the leaves whose `order` is below it (the inner,
+ * late-season leaves go first). The fragment cuts the leaf shape (SDF, anti-aliased), colours from
+ * the hash, the canopy depth and the season, and adds translucent back-light.
+ */
+export declare function leafMaterial(u: any, opts: any): {
+    material: THREE.MeshStandardMaterial;
+    depth: THREE.MeshDepthMaterial;
+};
+/** The leaf card: a 3×5 grid (so it can curl along and across) with instance buffers for `count` leaves. */
+export declare const CARD_NX = 3, CARD_NY = 5;
+/** Index counts: the curled grid, then the flat card that follows it. */
+export declare const CARD_IDX: number, FLAT_IDX = 6;
+export declare function leafGeometry(count: any): THREE.InstancedBufferGeometry;
+/** Writes leaf i: attachment, frame from (along = card +y, normal = card +z), size, hash, hf, ao, phase, flex, order, kind. */
+export declare function setLeaf(geo: any, i: any, pos: any, along: any, normal: any, size: any, hash: any, hf: any, ao: any, phase: any, flex: any, order: any, kind: any): void;
+/** The leaf's plant root (for growth). */
+export declare function setLeafRoot(geo: any, i: any, root: any): void;
+/** Bounds-only: the unit box, so Box3.expandByObject centres the gizmo on the plant (instanced attrs are not read). */
+export declare function unitBounds(geo: any): void;
+/**
+ * A parametric branching model (after Weber & Penn): each level has a child count, length and
+ * radius ratios, a down angle from the parent, a phyllotactic rotation, curvature and gravity
+ * (droop). A branch is a polyline with tapering radii; the crown silhouette is a shape function of
+ * the attachment height. Deterministic for a seed. Lengths in unit space (height 1).
+ *
+ * params:
+ *   levels          number of branch levels after the trunk (0..3)
+ *   trunk           { length, radius, taper, curve, segments, splits? }
+ *   level[i]        { count, length, radius, downAngle, downVar, curve, curveVar, segments, start }
+ *   shape(t)        crown silhouette multiplier for first-level branch length by attachment t
+ *   droop           gravity on the branches (negative lifts them)
+ *   twist           extra random curvature
+ *   leaves          { perLength, size, sizeVar, spread, fromLevel, tuft }
+ * Returns { branches: [{ level, pts, radii, hf0, phase, flex }], leaves: [{ pos, along, normal, size, hf, ao, phase, flex, order }] }.
+ */
+export declare function generatePlant(P: any, rnd: any): {
+    branches: any[];
+    leaves: any[];
+};
+/**
+ * Generalized cylinders for every branch, merged in one geometry: rings of `sides` vertices
+ * (fewer on thin branches) along the polyline, parallel-transport frames, a pointed cap.
+ * Attributes: position, normal, aRing (angle 0..1, length along), aWind (hf, phase, flex).
+ */
+export declare function branchGeometry(branches: any, opts: any): THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap>;
+/** Fills a leaf geometry from generatePlant's leaves (optionally the first `count`). */
+export declare function fillLeaves(geo: any, leaves: any, kind?: any): number;
+/**
+ * Hanging fruit: instanced low-poly spheroids at a subset of the leaf positions, shaped per kind in
+ * the vertex shader (oblate / prolate / dimple / taper), skinned per kind in the fragment (two
+ * colours by ripeness, waxy specular, pores / streaks), swinging with the branch.
+ * aPos, aInfo = (size, hash, hf, order), aWind = (phase, flex).
+ */
+export declare const FRUIT_KINDS: string[];
+export declare const FRUIT_PROFILES: {
+    apple: {
+        elong: number;
+        dimple: number;
+        taper: number;
+        size: number;
+        unripe: string;
+        ripe: string;
+        gloss: number;
+        streaks: number;
+        pores: number;
+    };
+    orange: {
+        elong: number;
+        dimple: number;
+        taper: number;
+        size: number;
+        unripe: string;
+        ripe: string;
+        gloss: number;
+        streaks: number;
+        pores: number;
+    };
+    lemon: {
+        elong: number;
+        dimple: number;
+        taper: number;
+        size: number;
+        unripe: string;
+        ripe: string;
+        gloss: number;
+        streaks: number;
+        pores: number;
+    };
+    cherry: {
+        elong: number;
+        dimple: number;
+        taper: number;
+        size: number;
+        unripe: string;
+        ripe: string;
+        gloss: number;
+        streaks: number;
+        pores: number;
+    };
+    pear: {
+        elong: number;
+        dimple: number;
+        taper: number;
+        size: number;
+        unripe: string;
+        ripe: string;
+        gloss: number;
+        streaks: number;
+        pores: number;
+    };
+    plum: {
+        elong: number;
+        dimple: number;
+        taper: number;
+        size: number;
+        unripe: string;
+        ripe: string;
+        gloss: number;
+        streaks: number;
+        pores: number;
+    };
+    berry: {
+        elong: number;
+        dimple: number;
+        taper: number;
+        size: number;
+        unripe: string;
+        ripe: string;
+        gloss: number;
+        streaks: number;
+        pores: number;
+    };
+    rosehip: {
+        elong: number;
+        dimple: number;
+        taper: number;
+        size: number;
+        unripe: string;
+        ripe: string;
+        gloss: number;
+        streaks: number;
+        pores: number;
+    };
+};
+export declare function fruitMaterial(u: any): {
+    material: THREE.MeshStandardMaterial;
+    depth: THREE.MeshDepthMaterial;
+};
+export declare function applyFruitConfig(mat: any, c: any): void;
+export declare function fruitGeometry(count: any, detail: any): THREE.InstancedBufferGeometry;
+/** Fruit at a seeded subset of the outer leaves; `size` in unit space (fruit radius ≈ size/2 × profile size). */
+export declare function fillFruit(geo: any, leaves: any, rnd: any, size: any): void;
+/**
+ * Leaves letting go: a small instanced card layer. Each card cycles analytically — released from a
+ * canopy leaf's position, it falls with a side-to-side glide and a tumble, drifts with the wind,
+ * and fades at the ground; then starts again. `uLeafFall` says how many are
+ * in the air; the season releases more.
+ */
+export declare function fallingMaterial(u: any): {
+    material: THREE.MeshStandardMaterial;
+    depth: THREE.MeshDepthMaterial;
+};
+/** A shadow-casting mesh from a geometry and a { material, depth } pair; clicks pass through. */
+export declare function plantMesh(geo: any, pair: any, name: any): THREE.Mesh<any, any, THREE.Object3DEventMap>;
+/** The quality table every plant uses: a multiplier on counts. */
+export declare const QUALITY_V: {
+    low: number;
+    medium: number;
+    high: number;
+};
+/**
+ * Bent blades: one instanced strip (2 × SEG+1 vertices) per blade. Per instance: aPos (root), aInfoA =
+ * (height, width, yaw, hash), aInfoB = (bend, phase, order, kind). In the vertex the blade curves
+ * along its bend direction (quadratic, tip bends most), the wind field bends it further ∝ t²
+ * (plantDisplace with hf = t) plus a travelling ripple. The fragment
+ * shades a base-to-tip gradient with per-blade variation and translucency.
+ */
+export declare const BLADE_SEG = 6;
+export declare function bladeGeometry(count: any): THREE.InstancedBufferGeometry;
+export declare function setBlade(geo: any, i: any, pos: any, height: any, width: any, yaw: any, hash: any, bend: any, phase: any, order: any, kind: any): void;
+export declare function bladeMaterial(u: any, opts: any): {
+    material: THREE.MeshStandardMaterial;
+    depth: THREE.MeshDepthMaterial;
+};
+/** Seeded positions over the unit footprint with clumping: jittered grid, kept where a clump noise says so. */
+export declare function clumpedPositions(count: any, rnd: any, clumping: any, margin: any): any[];
+/**
+ * Flower heads at branch tips (blossom on trees, flowers on shrubs): each head is a fan of petal cards
+ * around the tip (a `head` of several florets scattered in a small dome for panicles), coloured by its
+ * own uniforms. `uFoliage` of the head material is the flowers knob (0..1 keeps that share of heads).
+ * spec: { petals, size, color, head?, type?, hang? }. Returns { geo, pair, U } (U.uFoliage / U.uColor).
+ */
+export declare function flowerHeads(u: any, tips: any, rnd: any, spec: any, maxHeads: any, matOpts?: any): {
+    geo: THREE.InstancedBufferGeometry;
+    pair: {
+        material: THREE.MeshStandardMaterial;
+        depth: THREE.MeshDepthMaterial;
+    };
+    U: any;
+};
+/** The plant's screen size s from a drawn mesh's matrixWorld — the same formula as vegLodS (GLSL). */
+export declare function lodScreenSize(m: any, u: any): number;
+/** The share of the leaves drawn at screen size s (vegLodFrac). */
+export declare function lodFrac(s: any): number;
+/** The lod knob: auto (by distance), full (never reduce — a hero plant), impostor (always the far card). */
+export declare const LOD_MODES: string[];
+export declare function applyLodMode(u: any, mode: any): void;
+/** Leaves in a random order (own stream, so the plant's other random draws are unchanged): drawing the first K is an even thinning. */
+export declare function lodOrder(list: any, seed: any): any;
+/**
+ * The impostor card: one quad billboarded toward the camera in the vertex shader (toward the light in the
+ * shadow pass — the depth material runs the same code with the shadow camera), textured from the 8×8
+ * hemi-octahedral atlas: the view direction in the plant's own frame picks the three nearest baked views
+ * and their weights; each pixel of the card is projected onto each view's plane (no parallax: fine at the
+ * distances it is drawn) and the three samples are blended. Albedo + plant-space normal, so the scene's sun
+ * lights it like the plant. `position` holds unit-box corners (gizmo bounds); the card is aCorner.
+ */
+export declare const IMP_N = 8, IMP_FRAME = 128, IMP_CHUNK = 16, IMP_MARGIN = 1.04;
+export declare function impostorMaterial(u: any): {
+    material: THREE.MeshStandardMaterial;
+    depth: THREE.MeshDepthMaterial;
+    own: {
+        uImpC: {
+            value: any;
+        };
+        uImpN: {
+            value: any;
+        };
+        uImpGrid: {
+            value: number;
+        };
+        uImpR: {
+            value: number;
+        };
+        uImpScale: {
+            value: THREE.Vector3;
+        };
+    };
+};
+export declare function plantLod(u: any, object: any, parts: any): {
+    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;
+    };
+    /** Per frame, after updateCommon: hides empty parts, bakes when wanted and stale. */
+    update(dt: any, renderer: any): void;
+    /** After every apply: the lod knob, and a re-bake when a knob that changes the look moved. */
+    applied(cfg: any): void;
+    dispose(): void;
+};
+//# sourceMappingURL=vegetationCore.d.ts.map

package/dist/components/vegetation/vegetationCore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vegetationCore.d.ts","sourceRoot":"","sources":["../../../src/components/vegetation/vegetationCore.ts"],"names":[],"mappings":"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"}