@3driseai/3drise-viewer 0.1.41 → 0.1.43

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

@@ -0,0 +1,213 @@
+import * as THREE from 'three';
+export declare const SPECIES: {
+    englishIvy: {
+        leaf: string;
+        size: number;
+        color: string;
+        shade: string;
+        bark: string;
+        autumn: string[];
+    };
+    virginiaCreeper: {
+        leaf: string;
+        size: number;
+        color: string;
+        shade: string;
+        bark: string;
+        autumn: string[];
+    };
+    bougainvillea: {
+        leaf: string;
+        size: number;
+        color: string;
+        shade: string;
+        bark: string;
+        autumn: string[];
+        flower: {
+            petals: number;
+            size: number;
+            color: string;
+            head: number;
+            cup: number;
+        };
+        flowersAlways: number;
+    };
+    jasmine: {
+        leaf: string;
+        size: number;
+        color: string;
+        shade: string;
+        bark: string;
+        autumn: string[];
+        flower: {
+            petals: number;
+            size: number;
+            color: string;
+            head: number;
+            cup: number;
+        };
+        flowersAlways: number;
+    };
+    wisteria: {
+        leaf: string;
+        size: number;
+        color: string;
+        shade: string;
+        bark: string;
+        autumn: string[];
+        flower: {
+            petals: number;
+            size: number;
+            color: string;
+            head: number;
+            cup: number;
+            hang: boolean;
+        };
+        flowersAlways: number;
+    };
+    climbingRose: {
+        leaf: string;
+        size: number;
+        color: string;
+        shade: string;
+        bark: string;
+        autumn: string[];
+        flower: {
+            petals: number;
+            size: number;
+            color: string;
+            head: number;
+            cup: number;
+            type: string;
+        };
+        flowersAlways: number;
+    };
+    honeysuckle: {
+        leaf: string;
+        size: number;
+        color: string;
+        shade: string;
+        bark: string;
+        autumn: string[];
+        flower: {
+            petals: number;
+            size: number;
+            color: string;
+            head: number;
+            cup: number;
+            type: string;
+        };
+        flowersAlways: number;
+    };
+    grapevine: {
+        leaf: string;
+        size: number;
+        color: string;
+        shade: string;
+        bark: string;
+        autumn: string[];
+    };
+};
+export declare function createUniforms(): {
+    uTime: {
+        value: number;
+    };
+    uWindPhase: {
+        value: number;
+    };
+    uWindDir: {
+        value: THREE.Vector2;
+    };
+    uWindStrength: {
+        value: number;
+    };
+    uTurb: {
+        value: number;
+    };
+    uSpeed: {
+        value: number;
+    };
+    uSway: {
+        value: number;
+    };
+    uFlutter: {
+        value: number;
+    };
+    uScale: {
+        value: THREE.Vector3;
+    };
+    uMean: {
+        value: number;
+    };
+    uOpacity: {
+        value: number;
+    };
+    uColor: {
+        value: THREE.Color;
+    };
+    uShadeColor: {
+        value: THREE.Color;
+    };
+    uSeason: {
+        value: number;
+    };
+    uFoliage: {
+        value: number;
+    };
+    uLeafType: {
+        value: number;
+    };
+    uLeafSize: {
+        value: number;
+    };
+    uGrowth: {
+        value: number;
+    };
+    uSunDirView: {
+        value: THREE.Vector3;
+    };
+    uViewPos: {
+        value: THREE.Vector3;
+    };
+    uLodK: {
+        value: number;
+    };
+    uLodOrtho: {
+        value: number;
+    };
+    uLodBias: {
+        value: number;
+    };
+    uImpReady: {
+        value: number;
+    };
+    uBake: {
+        value: number;
+    };
+    uBakeView: {
+        value: THREE.Matrix3;
+    };
+    uBakeDepth: {
+        value: THREE.Vector2;
+    };
+} & {
+    uLeafType: {
+        value: number;
+    };
+};
+export declare function speciesColors(c: any): any;
+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: (cfg2: any) => void;
+    update: (dt: any, camera: any, sunWorld: any) => void;
+    stats: {
+        vines: number;
+        leaves: 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=ivy.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ivy.d.ts","sourceRoot":"","sources":["../../../../src/components/vegetation/core/ivy.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAO/B,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CASnB,CAAC;AAKF,wBAAgB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA2G;AAEzI,wBAAgB,aAAa,CAAC,CAAC,KAAA,OAQ9B;AAED,wBAAgB,WAAW,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA,EAAE,IAAI,KAAA,QAOrC;AAiDD,wBAAgB,KAAK,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA;;;;;;;;;;EAuCzB;AAED,8GAA8G;AAC9G,eAAO,MAAM,UAAU,UAAoF,CAAC"}

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

@@ -0,0 +1,173 @@
+// Emitted from Claude outputs/vegetation-lab/ivy.mjs by gen_family.mjs — edit the lab module and re-emit.
+// vegetation/core/ivy — Ivy (type 'vegetation', config.type 'ivy'). Shared core: ../vegetationCore.
+// Construction: climbing vines on the faces of the object's box (place the box against a wall or
+// around a pillar): each vine is a 2-D random walk up the face — upward tropism, wander, a chance to
+// branch at each step, thinning as it climbs — mapped onto the face a few centimetres proud of it.
+// Leaves (ivy's three-lobed cards) hang off the vines facing away from the wall, older and bigger
+// low down, young and small at the tips. `growth` draws the vines from the ground up (the part past
+// the growth front collapses onto its axis, leaves past it are not there yet), so ivy can be animated
+// climbing a wall. Wind: only the leaves flutter and the loose tips sway. Size: the box's faces.
+import * as THREE from 'three';
+import { mulberry32, setColor, createCommonUniforms, applyCommonConfig, updateCommon, QUALITY_V, LEAF_TYPES, branchGeometry, leafGeometry, fillLeaves, unitBounds, barkMaterial, leafMaterial, plantMesh, flowerHeads, } from '../vegetationCore.js';
+// species: leaf type and size, colours, autumn turn, flowers at the vine tips (hang = racemes)
+export const SPECIES = {
+    englishIvy: { leaf: 'heart', size: 1, color: '#3f7a2e', shade: '#1a3617', bark: '#5a4a38', autumn: ['#c89a2a', '#8a3a1a'] },
+    virginiaCreeper: { leaf: 'maple', size: 1.2, color: '#4f8a3a', shade: '#1e3a1a', bark: '#5a4a38', autumn: ['#d8402a', '#7a1a1a'] },
+    bougainvillea: { leaf: 'broadleaf', size: 0.7, color: '#4f8a3a', shade: '#1e3a1a', bark: '#6a5a4a', autumn: ['#c89a3a', '#8a5a2a'], flower: { petals: 3, size: 0.03, color: '#e0207a', head: 6, cup: 0.3 }, flowersAlways: 1 },
+    jasmine: { leaf: 'round', size: 0.5, color: '#3f7a3a', shade: '#1a3a1f', bark: '#5a5a48', autumn: ['#9a9a4a', '#6a6a3a'], flower: { petals: 5, size: 0.012, color: '#fbf8f0', head: 4, cup: 0.2 }, flowersAlways: 0.8 },
+    wisteria: { leaf: 'frond', size: 1.3, color: '#5f9a4a', shade: '#2a4a1f', bark: '#6a5a48', autumn: ['#d8b84a', '#9a7a2a'], flower: { petals: 4, size: 0.012, color: '#b8a0e8', head: 26, cup: 0.5, hang: true }, flowersAlways: 0.9 },
+    climbingRose: { leaf: 'broadleaf', size: 0.7, color: '#3f7a2e', shade: '#1a3617', bark: '#5a4a38', autumn: ['#c89a3a', '#8a5a2a'], flower: { petals: 8, size: 0.03, color: '#e85a7a', head: 1, cup: 0.7, type: 'round' }, flowersAlways: 0.6 },
+    honeysuckle: { leaf: 'round', size: 0.8, color: '#5f9a4a', shade: '#2a4a1f', bark: '#6a5a48', autumn: ['#c8a84a', '#8a6a3a'], flower: { petals: 5, size: 0.016, color: '#f6e0a0', head: 5, cup: 0.6, type: 'lanceolate' }, flowersAlways: 0.7 },
+    grapevine: { leaf: 'maple', size: 1.5, color: '#5f9a3a', shade: '#2a4a1f', bark: '#5a4a38', autumn: ['#d8a82a', '#8a4a1a'] },
+};
+const FACES = { back: [[0, 0, -1]], front: [[0, 0, 1]], sides: [[0, 0, -1], [0, 0, 1]], around: [[0, 0, -1], [1, 0, 0], [0, 0, 1], [-1, 0, 0]] };
+const LEAF_BASE = 5000;
+export function createUniforms() { return Object.assign(createCommonUniforms(), { uLeafType: { value: LEAF_TYPES.indexOf('heart') } }); }
+export function speciesColors(c) {
+    const sp = SPECIES[c.species] || SPECIES.englishIvy;
+    const all = Object.values(SPECIES);
+    const out = Object.create(null); // only the keys set below override the config
+    if (!c.color || all.some((s) => s.color.toLowerCase() === c.color.toLowerCase()))
+        out.color = sp.color;
+    if (!c.shadeColor || all.some((s) => s.shade.toLowerCase() === c.shadeColor.toLowerCase()))
+        out.shadeColor = sp.shade;
+    if (!c.barkColor || all.some((s) => s.bark.toLowerCase() === c.barkColor.toLowerCase()))
+        out.barkColor = sp.bark;
+    return out;
+}
+export function applyConfig(u, c, mats) {
+    if (c.species !== undefined) {
+        c = Object.assign({}, c, speciesColors(c));
+        u.uLeafType.value = Math.max(0, LEAF_TYPES.indexOf((SPECIES[c.species] || SPECIES.englishIvy).leaf));
+    }
+    applyCommonConfig(u, Object.assign({}, c, { leafType: undefined }));
+    if (!mats)
+        return;
+    if (c.barkColor !== undefined)
+        setColor(mats.bark.userData.uniforms.uBarkColor, c.barkColor);
+    if (c.flowers !== undefined && mats.flowerU)
+        mats.flowerU.uFoliage.value = c.flowers;
+    if (c.flowerColor !== undefined && c.flowerColor !== '#ffffff' && mats.flowerU)
+        setColor(mats.flowerU.uColor, c.flowerColor);
+}
+/** Vines on one face: 2-D walks (s across 0..1, h up 0..1) → 3-D on the face, proud by `off`. */
+function growFace(normal, c, rnd, branches, leaves, off) {
+    const n = new THREE.Vector3(...normal);
+    const right = new THREE.Vector3().crossVectors(new THREE.Vector3(0, 1, 0), n).normalize();
+    const toWorld = (s, h, lift) => new THREE.Vector3().addScaledVector(right, s - 0.5).addScaledVector(n, 0.5 - off - lift).setY(h);
+    const reach = c.reach ?? 1, branching = c.branching ?? 0.5;
+    const stack = [];
+    const nV = Math.max(1, Math.round(c.vines ?? 7));
+    for (let i = 0; i < nV; i++)
+        stack.push({ s: (i + 0.3 + 0.4 * rnd()) / nV, h: 0, dir: (rnd() - 0.5) * 0.6, r: 0.006, dist: 0, level: 0, phase: rnd() });
+    const step = 0.035;
+    let maxDist = 1e-6;
+    while (stack.length) {
+        const v = stack.pop();
+        const pts = [], radii = [], dist = [];
+        let { s, h, dir, r } = v, d = v.dist;
+        const len = (0.4 + 0.6 * rnd()) * reach * (v.level ? 0.5 : 1.2);
+        let travelled = 0;
+        pts.push(toWorld(s, h, 0));
+        radii.push(r);
+        dist.push(d);
+        while (travelled < len && h < reach * 0.98 && r > 0.0012) {
+            // tropism: mostly up, wandering; a vine that reaches the top edge turns sideways
+            dir += (rnd() - 0.5) * 0.9;
+            dir *= 0.85;
+            if (h > reach * 0.9)
+                dir += (dir > 0 ? 1 : -1) * 0.4;
+            const ang = dir;
+            s += Math.sin(ang) * step;
+            h += Math.cos(ang) * step * (0.6 + 0.4 * rnd());
+            if (s < 0.03 || s > 0.97) {
+                dir = -dir * 1.5;
+                s = Math.min(0.97, Math.max(0.03, s));
+            }
+            travelled += step;
+            d += step;
+            r *= 0.985;
+            pts.push(toWorld(s, h, 0.002 * rnd()));
+            radii.push(r);
+            dist.push(d);
+            if (rnd() < branching * 0.18 && v.level < 3 && r > 0.002)
+                stack.push({ s, h, dir: dir + (rnd() < 0.5 ? 1 : -1) * (0.8 + rnd() * 0.8), r: r * 0.7, dist: d, level: v.level + 1, phase: rnd() });
+            // a leaf every step or two: facing out from the wall, older (bigger) low down
+            // leaves: two or three a step, lying flat against the wall (along in the wall plane, pointing
+            // sideways and down; normal out of the wall), older and bigger low down
+            const nLeaf = 2 + Math.floor(rnd() * 2);
+            for (let k = 0; k < nLeaf; k++) {
+                const side = rnd() < 0.5 ? -1 : 1;
+                const along = new THREE.Vector3().addScaledVector(right, side * (0.4 + 0.6 * rnd())).addScaledVector(n, 0.15 * rnd()).setY(-0.3 - 0.7 * rnd()).normalize();
+                const nrm = new THREE.Vector3().addScaledVector(n, 1).addScaledVector(right, (rnd() - 0.5) * 0.4).setY((rnd() - 0.3) * 0.4).normalize();
+                const age = Math.min(1, 1.2 - h / Math.max(reach, 0.1));
+                leaves.push({ pos: toWorld(s + (rnd() - 0.5) * 0.02, h + (rnd() - 0.5) * 0.02, 0.015 + 0.03 * rnd()), along, normal: nrm, size: (0.05 + 0.04 * age) * (0.8 + 0.4 * rnd()), hf: h, ao: 0.6 + 0.4 * rnd(), phase: v.phase, flex: 0.25, order: rnd(), grow: d });
+            }
+        }
+        if (d > maxDist)
+            maxDist = d;
+        if (pts.length > 1)
+            branches.push({ level: v.level, pts, radii, hf0: v.h, phase: v.phase, flex: 0.08, dist });
+    }
+    return maxDist;
+}
+export function build(u, c) {
+    const q = QUALITY_V[c.quality] || 1;
+    const sp = SPECIES[c.species] || SPECIES.englishIvy;
+    c = Object.assign({}, c, speciesColors(c));
+    const rnd = mulberry32((c.seed ?? 13) * 2654435761 + 131);
+    const faces = FACES[c.faces] || FACES.back;
+    const branches = [], leaves = [];
+    let maxDist = 1e-6;
+    for (const f of faces)
+        maxDist = Math.max(maxDist, growFace(f, c, rnd, branches, leaves, 0.02));
+    // growth: distance along the vine normalised to the longest vine
+    for (const b of branches) {
+        b.grow = b.dist.map((d) => d / maxDist);
+        b.flex = 0.08;
+    }
+    for (const l of leaves) {
+        l.grow = l.grow / maxDist;
+        l.size *= sp.size;
+    }
+    // leaf budget
+    let picked = leaves;
+    const target = Math.round(LEAF_BASE * (c.density ?? 1) * q * faces.length);
+    if (picked.length > target) {
+        picked = [];
+        for (let i = 0; i < target; i++)
+            picked.push(leaves[Math.floor(rnd() * leaves.length)]);
+    }
+    const barkPair = barkMaterial(u, { barkColor: c.barkColor || '#5a4a38', ridges: 0.4 });
+    const leafPair = leafMaterial(u, { translucency: 0.45, veins: 0.7, autumnA: sp.autumn[0], autumnB: sp.autumn[1] });
+    // flowers at the vine tips
+    const tipsB = branches.filter((b) => b.level >= 1 || branches.length < 8);
+    const fl = sp.flower || { petals: 5, size: 0.015, color: '#fbf8f0', head: 3, cup: 0.3 };
+    const heads = flowerHeads(u, tipsB.length ? tipsB : branches, rnd, Object.assign({}, fl, { color: c.flowerColor && c.flowerColor !== '#ffffff' ? c.flowerColor : fl.color }), Math.round(700 * q / Math.max(1, Math.sqrt(fl.head || 1))));
+    const barkGeo = branchGeometry(branches, { sides: [5, 4, 4, 3] });
+    unitBounds(barkGeo);
+    const leafGeo = leafGeometry(Math.max(1, picked.length));
+    fillLeaves(leafGeo, picked);
+    unitBounds(leafGeo);
+    const object = new THREE.Group();
+    object.name = 'ivy';
+    object.add(plantMesh(barkGeo, barkPair, 'vines'), plantMesh(leafGeo, leafPair, 'leaves'), plantMesh(heads.geo, heads.pair, 'flowers'));
+    const mats = { bark: barkPair.material, flowerU: heads.U };
+    const cfg = Object.assign({}, c);
+    if (sp.flowersAlways && (c.flowers ?? 0) === 0)
+        cfg.flowers = sp.flowersAlways;
+    applyConfig(u, cfg, mats);
+    return {
+        object,
+        materials: [barkPair.material, leafPair.material, heads.pair.material],
+        apply: function (cfg2) { applyConfig(u, cfg2, mats); },
+        update: function (dt, camera, sunWorld) { updateCommon(u, object, camera, dt, sunWorld); },
+        stats: { vines: branches.length, leaves: picked.length },
+        dispose: function () { barkGeo.dispose(); leafGeo.dispose(); heads.geo.dispose(); for (const p of [barkPair, leafPair, heads.pair]) {
+            p.material.dispose();
+            p.depth.dispose();
+        } },
+    };
+}
+/** Knobs whose change rebuilds the plant (dispose + build); every other knob is a live push through apply. */
+export const STRUCTURAL = ['species', 'faces', 'vines', 'branching', 'reach', 'density', 'quality', 'seed'];