@3driseai/3drise-viewer 0.1.41 → 0.1.43

package/dist/components/urban/core/building.js

@@ -0,0 +1,741 @@
+// Emitted from Claude outputs/urban-lab/building.mjs by emit_object.mjs — edit the lab module and re-emit.
+// =============================================================================
+// urban/building — a parametric building: boxes with a facade drawn per fragment
+// =============================================================================
+// Construction. A building is a few VOLUMES — unit cubes, plus a gable prism, a frustum
+// (mansard) and a cylinder (round towers, helipads) — each an instance of ONE unit geometry
+// in one InstancedMesh per geometry kind, all sharing the facade material: a building is
+// at most four draw calls and ~12 triangles per volume. Footprints: box, L, U, courtyard,
+// stepped setbacks, slab, tower-on-podium, twin towers on a podium, cylinder. The facade
+// is not geometry: the fragment shader turns the face-local metres (u along the face, v
+// up; around the circumference on a cylinder) into floors and bays, then into glass /
+// spandrel / mullion / wall, anti-aliased with fwidth. Eight window patterns: curtain wall,
+// punched, ribbon, brick (running bond + lintels), balconies (recessed, slab + railing),
+// concrete panel (joints), glass fins (vertical louvres) and industrial (tall windows,
+// roller doors). Roofs: flat, parapet, mechanical box, pitched (gable), mansard, helipad
+// (marked disc), hip, crown (an emissive band at night), green (lawn).
+//
+// Optics. Glass = a dark interior tinted by the glass colour under a Fresnel-weighted sky
+// reflection (sky above the horizon, ground below) plus a sun glint; the wall is a
+// library texture set (colour / normal / roughness) whose colour is normalised to its
+// mean so the wall colour knob decides the albedo. At night a per-window hash lights a
+// share of the rooms (windowLights) in a warm / cool mix; the emissive is in the shader,
+// never a light. Street lamps reach the facade through the shared lamp list (lampLight).
+//
+// The same geometry builder is used by `block`, which adds many buildings to the same
+// InstancedMesh.
+import * as THREE from 'three';
+import { mulberry32, createSunUniforms, createLampUniforms, createTextureUniforms, applyTextureSet, glslTextureBlock, GLSL_COMMON, GLSL_FOG_PARS, GLSL_FOG_VERT_PARS, GLSL_OUT, loadTextureSet, } from '../urbanCore.js';
+export const FOOTPRINTS = ['box', 'lShape', 'podiumTower', 'uShape', 'courtyard', 'stepped', 'slab', 'twinTowers', 'cylinder'];
+export const FACADES = ['curtainWall', 'punched', 'ribbon', 'brick', 'balconies', 'concretePanel', 'glassFins', 'industrial'];
+export const ROOFS = ['flat', 'parapet', 'mechanical', 'pitched', 'hip', 'mansard', 'helipad', 'crown', 'green'];
+export const LIGHTING = ['auto', 'day', 'night'];
+// ---------------------------------------------------------------------------- mixes
+// A mix is a city character: weights over footprints, facades and roofs, a floor range and
+// whether ground floors are lobbies. `block` and `skyline` draw their buildings from one.
+export const MIXES = ['custom', 'downtown', 'residential', 'oldTown', 'industrial', 'suburb'];
+const MIX_TABLE = {
+    downtown: { footprints: { box: 3, podiumTower: 3, twinTowers: 1, stepped: 2, cylinder: 1 }, facades: { curtainWall: 4, ribbon: 2, glassFins: 3, concretePanel: 1 }, roofs: { parapet: 3, mechanical: 3, helipad: 1, crown: 2, flat: 1 }, floors: [8, 40], lobby: true },
+    residential: { footprints: { slab: 3, uShape: 2, courtyard: 2, box: 2, lShape: 1 }, facades: { balconies: 4, ribbon: 1, punched: 2 }, roofs: { parapet: 2, flat: 2, green: 1, mechanical: 1 }, floors: [4, 12], lobby: false },
+    oldTown: { footprints: { box: 4, lShape: 2, courtyard: 2 }, facades: { brick: 4, punched: 3 }, roofs: { mansard: 3, pitched: 2, hip: 1, parapet: 1 }, floors: [3, 6], lobby: false },
+    industrial: { footprints: { box: 4, slab: 2, lShape: 1 }, facades: { industrial: 4, concretePanel: 2 }, roofs: { flat: 3, pitched: 2, parapet: 1 }, floors: [1, 3], lobby: false },
+    suburb: { footprints: { box: 4, lShape: 3 }, facades: { punched: 3, brick: 2 }, roofs: { pitched: 3, hip: 3, mansard: 1 }, floors: [1, 3], lobby: false },
+};
+function weighted(rng, table) {
+    let total = 0;
+    for (const k in table)
+        total += table[k];
+    let r = rng() * total;
+    for (const k in table) {
+        r -= table[k];
+        if (r <= 0)
+            return k;
+    }
+    return Object.keys(table)[0];
+}
+/** One building's picks from a mix (null for 'custom'): { footprint, facade, roof, floors, lobby }. */
+export function pickMix(rng, mix) {
+    const m = MIX_TABLE[mix];
+    if (!m)
+        return null;
+    const floors = Math.round(m.floors[0] + (m.floors[1] - m.floors[0]) * Math.pow(rng(), 1.4));
+    return { footprint: weighted(rng, m.footprints), facade: weighted(rng, m.facades), roof: weighted(rng, m.roofs), floors, lobby: m.lobby };
+}
+/** Structural knobs: the instance list is rebuilt when one changes. */
+export const STRUCTURAL = ['footprint', 'width', 'depth', 'floors', 'floorHeight', 'lobby', 'roof', 'seed', 'texture', 'facade', 'windowRatio', 'bayWidth', 'windowLights'];
+// ---------------------------------------------------------------------------- instance list
+// Each entry is one unit-geometry instance: { geo, x, y, z, ry, w, h, d, seed, floors, floorH, style, kind, ratio, bay, lights, tint }.
+// geo: 'box' (default) | 'prism' (gable roof) | 'hipEnd' (one sloped end of a hip roof) | 'frustum' (mansard) | 'cyl' (round tower, helipad, discs).
+// style: 0 facade volume with lobby, 1 solid wall-coloured, 2 facade volume without lobby,
+//        3 roof-coloured solid (kind = marking: 0 plain, 1 helipad, 2 lawn), 4 crown (emissive band at night).
+//        +10 on a cylinder facade: the shader maps bays around the circumference.
+export const STYLE_FACADE = 0, STYLE_SOLID = 1, STYLE_UPPER = 2, STYLE_ROOF = 3, STYLE_CROWN = 4, ROUND = 10;
+export const MARK_NONE = 0, MARK_HELIPAD = 1, MARK_LAWN = 2;
+function lobbyHeight(c) { return c.lobby ? c.floorHeight * 1.6 : c.floorHeight; }
+/** Push the instances of one building described by `c` (building knobs) at (x, z) turned ry, into `list`. */
+export function addBuilding(list, c, x, z, ry = 0, tint = [1, 1, 1], seed = undefined) {
+    const rng = mulberry32((seed === undefined ? c.seed : seed) * 1013 + 17);
+    const fl = Math.max(1, Math.round(c.floors));
+    const fh = c.floorHeight;
+    const hTotal = lobbyHeight(c) + (fl - 1) * fh;
+    const kind = Math.max(0, FACADES.indexOf(c.facade));
+    const base = { seed: Math.floor(rng() * 100000), floorH: fh, kind, ratio: c.windowRatio, bay: c.bayWidth, lights: c.windowLights, tint: tint || [1, 1, 1] };
+    const cs = Math.cos(ry), sn = Math.sin(ry);
+    /** One volume at a local offset (rotated by ry about the building origin). extra: { y, geo, kind }. */
+    const vol = (lx, lz, w, h, d, floors, style, extra = {}) => {
+        const it = Object.assign({ geo: 'box', x: x + lx * cs + lz * sn, z: z - lx * sn + lz * cs, ry, w, h, d, floors, style }, base, style === STYLE_ROOF ? { kind: MARK_NONE } : {}, extra);
+        list.push(it);
+        return it;
+    };
+    const floorsH = (n) => lobbyHeight(c) + (n - 1) * fh;
+    /** Parapet walls around a rectangle at height `top`. */
+    const parapet = (lx, lz, w, d, top, style = STYLE_SOLID, ph = 0.9) => {
+        const t = 0.3;
+        vol(lx, lz - d / 2 + t / 2, w, ph, t, 0, style, { y: top });
+        vol(lx, lz + d / 2 - t / 2, w, ph, t, 0, style, { y: top });
+        vol(lx - w / 2 + t / 2, lz, t, ph, d - 2 * t, 0, style, { y: top });
+        vol(lx + w / 2 - t / 2, lz, t, ph, d - 2 * t, 0, style, { y: top });
+    };
+    const plantBox = (lx, lz, w, d, top) => {
+        const mw = Math.max(2.5, w * (0.25 + rng() * 0.15)), md = Math.max(2.5, d * (0.25 + rng() * 0.15));
+        vol(lx + (rng() - 0.5) * (w - mw) * 0.7, lz + (rng() - 0.5) * (d - md) * 0.7, mw, 2.6 + rng() * 1.2, md, 0, STYLE_SOLID, { y: top });
+    };
+    /** The roof of a rectangular volume (w x d, top at `top`) per c.roof. */
+    const roofBits = (lx, lz, w, d, top) => {
+        const r = c.roof;
+        if (r === 'parapet' || r === 'mechanical' || r === 'helipad' || r === 'green')
+            parapet(lx, lz, w, d, top);
+        if (r === 'mechanical')
+            plantBox(lx, lz, w, d, top);
+        if (r === 'pitched' || r === 'hip') {
+            // Ridge along the longer side, ~29 degrees, eaves of 0.3 m, a fascia board under it.
+            const along = w >= d;
+            const span = (along ? d : w) + 0.6, len = (along ? w : d) + 0.6;
+            const rise = span * 0.5 * 0.55;
+            const rot = along ? ry : ry + Math.PI / 2;
+            vol(lx, lz, len, 0.3, span, 0, STYLE_ROOF, { y: top });
+            if (r === 'pitched') {
+                vol(lx, lz, len, rise, span, 0, STYLE_ROOF, { y: top + 0.3, geo: 'prism', ry: rot });
+            }
+            else {
+                // Hip: a shorter ridge prism and two sloped ends (half-pyramids, same pitch as the sides).
+                const endL = Math.min(span * 0.5, len * 0.5), mid = len - 2 * endL;
+                const off = (t) => along ? [lx + t, lz] : [lx, lz + t];
+                if (mid > 0.05)
+                    vol(lx, lz, mid, rise, span, 0, STYLE_ROOF, { y: top + 0.3, geo: 'prism', ry: rot });
+                const [ex1, ez1] = off(mid / 2 + endL / 2), [ex2, ez2] = off(-(mid / 2 + endL / 2));
+                vol(ex1, ez1, endL, rise, span, 0, STYLE_ROOF, { y: top + 0.3, geo: 'hipEnd', ry: rot });
+                vol(ex2, ez2, endL, rise, span, 0, STYLE_ROOF, { y: top + 0.3, geo: 'hipEnd', ry: rot + Math.PI });
+            }
+        }
+        if (r === 'mansard') {
+            const h = Math.min(3.2, 0.9 + Math.min(w, d) * 0.12);
+            vol(lx, lz, w + 0.4, h, d + 0.4, 0, STYLE_ROOF, { y: top, geo: 'frustum' });
+        }
+        if (r === 'helipad') {
+            const rad = Math.min(w, d) * 0.34;
+            vol(lx, lz, rad * 2, 0.3, rad * 2, 0, STYLE_ROOF, { y: top, geo: 'cyl', kind: MARK_HELIPAD });
+        }
+        if (r === 'crown') {
+            parapet(lx, lz, w, d, top, STYLE_CROWN, 1.4);
+            plantBox(lx, lz, w, d, top);
+        }
+        if (r === 'green')
+            vol(lx, lz, w - 0.8, 0.14, d - 0.8, 0, STYLE_ROOF, { y: top, kind: MARK_LAWN });
+    };
+    /** The roof of a round volume (diameter dia, top at `top`). */
+    const roundRoof = (lx, lz, dia, top) => {
+        const r = c.roof;
+        if (r === 'parapet' || r === 'mechanical' || r === 'green' || r === 'pitched' || r === 'hip' || r === 'mansard')
+            vol(lx, lz, dia + 0.6, 0.9, dia + 0.6, 0, STYLE_SOLID, { y: top, geo: 'cyl' });
+        if (r === 'mechanical' || r === 'pitched' || r === 'hip' || r === 'mansard')
+            vol(lx, lz, dia * 0.35, 2.8, dia * 0.35, 0, STYLE_SOLID, { y: top, geo: 'cyl' });
+        if (r === 'helipad')
+            vol(lx, lz, dia * 0.7, 0.3, dia * 0.7, 0, STYLE_ROOF, { y: top, geo: 'cyl', kind: MARK_HELIPAD });
+        if (r === 'crown')
+            vol(lx, lz, dia + 0.6, 1.4, dia + 0.6, 0, STYLE_CROWN, { y: top, geo: 'cyl' });
+        if (r === 'green')
+            vol(lx, lz, dia - 0.8, 0.14, dia - 0.8, 0, STYLE_ROOF, { y: top, geo: 'cyl', kind: MARK_LAWN });
+    };
+    /** A facade block: volume + its roof. */
+    const block = (lx, lz, w, d, floors, style = STYLE_FACADE, y = 0) => {
+        const h = style === STYLE_FACADE ? floorsH(floors) : floors * fh;
+        vol(lx, lz, w, h, d, floors, style, { y });
+        roofBits(lx, lz, w, d, y + h);
+        return y + h;
+    };
+    const W = c.width, D = c.depth;
+    switch (c.footprint) {
+        case 'lShape': {
+            // An L: the full-width front bar and a deeper wing on one side.
+            const wingW = W * 0.42, barD = D * 0.45;
+            block(0, D / 2 - barD / 2, W, barD, fl);
+            const wingFl = Math.max(1, Math.round(fl * (0.7 + rng() * 0.3)));
+            block(-W / 2 + wingW / 2, -barD / 2, wingW, D - barD, wingFl);
+            break;
+        }
+        case 'uShape': {
+            // A U: the back bar and two wings reaching forward, the court open to the front.
+            const wingW = Math.min(W * 0.3, 14), barD = Math.min(D * 0.4, 16);
+            block(0, D / 2 - barD / 2, W, barD, fl);
+            block(-W / 2 + wingW / 2, -barD / 2, wingW, D - barD, fl);
+            block(W / 2 - wingW / 2, -barD / 2, wingW, D - barD, fl);
+            break;
+        }
+        case 'courtyard': {
+            // A ring of four bars around an inner court (bar depth capped so the court stays).
+            const bd = Math.min(W, D) * 0.3;
+            block(0, D / 2 - bd / 2, W, bd, fl);
+            block(0, -D / 2 + bd / 2, W, bd, fl);
+            block(-W / 2 + bd / 2, 0, bd, D - 2 * bd, fl);
+            block(W / 2 - bd / 2, 0, bd, D - 2 * bd, fl);
+            break;
+        }
+        case 'stepped': {
+            // Setbacks: three tiers, each narrower, the upper ones without a lobby.
+            const f1 = Math.max(1, Math.round(fl * 0.45)), f2 = Math.max(0, Math.round(fl * 0.3)), f3 = Math.max(0, fl - f1 - f2);
+            let top = block(0, 0, W, D, f1);
+            if (f2 > 0)
+                top = block((rng() - 0.5) * W * 0.1, (rng() - 0.5) * D * 0.1, W * 0.74, D * 0.74, f2, STYLE_UPPER, top);
+            if (f3 > 0)
+                block((rng() - 0.5) * W * 0.08, (rng() - 0.5) * D * 0.08, W * 0.5, D * 0.5, f3, STYLE_UPPER, top);
+            break;
+        }
+        case 'slab': {
+            // A long thin bar (depth capped at 14 m) with stair / lift cores on the roof.
+            const d = Math.min(D, 14);
+            const top = block(0, 0, W, d, fl);
+            const cores = Math.max(1, Math.round(W / 28));
+            for (let i = 0; i < cores; i++)
+                vol(-W / 2 + W * (i + 0.5) / cores, 0, 3.2, 2.8, Math.min(d * 0.5, 5), 0, STYLE_SOLID, { y: top });
+            break;
+        }
+        case 'podiumTower': {
+            // Podium (2-3 floors, full footprint, lobby) with a slimmer tower on it.
+            const podFl = Math.min(fl, 2 + Math.round(rng()));
+            const top = block(0, 0, W, D, podFl);
+            const towFl = fl - podFl;
+            if (towFl > 0) {
+                const tw = W * 0.62, td = D * 0.62;
+                block((rng() - 0.5) * (W - tw) * 0.8, (rng() - 0.5) * (D - td) * 0.8, tw, td, towFl, STYLE_UPPER, top);
+            }
+            break;
+        }
+        case 'twinTowers': {
+            // Two towers side by side on one podium, one a little shorter.
+            const podFl = Math.min(fl, 2 + Math.round(rng()));
+            const top = block(0, 0, W, D, podFl);
+            const towFl = fl - podFl;
+            if (towFl > 0) {
+                const tw = W * 0.36, td = D * 0.62;
+                block(-W * 0.28, 0, tw, td, towFl, STYLE_UPPER, top);
+                block(W * 0.28, 0, tw, td, Math.max(1, Math.round(towFl * (0.7 + rng() * 0.3))), STYLE_UPPER, top);
+            }
+            break;
+        }
+        case 'cylinder': {
+            // A round tower: diameter = the smaller side; bays run around the circumference.
+            const dia = Math.min(W, D);
+            const h = floorsH(fl);
+            vol(0, 0, dia, h, dia, fl, STYLE_FACADE + ROUND, { geo: 'cyl' });
+            roundRoof(0, 0, dia, h);
+            break;
+        }
+        default:
+            block(0, 0, W, D, fl);
+    }
+    return list;
+}
+// ---------------------------------------------------------------------------- geometry
+const _m = new THREE.Matrix4(), _q = new THREE.Quaternion(), _p = new THREE.Vector3(), _s = new THREE.Vector3(1, 1, 1), _up = new THREE.Vector3(0, 1, 0);
+/** Flat-shaded geometry from triangles (each a list of 3 [x,y,z]). */
+function flatGeometry(tris) {
+    const pos = new Float32Array(tris.length * 9), nor = new Float32Array(tris.length * 9);
+    const a = new THREE.Vector3(), b = new THREE.Vector3(), c = new THREE.Vector3(), n = new THREE.Vector3();
+    tris.forEach((t, i) => {
+        a.fromArray(t[0]);
+        b.fromArray(t[1]);
+        c.fromArray(t[2]);
+        n.subVectors(b, a).cross(c.clone().sub(a)).normalize();
+        for (let k = 0; k < 3; k++) {
+            pos.set(t[k], i * 9 + k * 3);
+            nor.set([n.x, n.y, n.z], i * 9 + k * 3);
+        }
+    });
+    const g = new THREE.BufferGeometry();
+    g.setAttribute('position', new THREE.BufferAttribute(pos, 3));
+    g.setAttribute('normal', new THREE.BufferAttribute(nor, 3));
+    return g;
+}
+const quad = (p0, p1, p2, p3) => [[p0, p1, p2], [p0, p2, p3]];
+/** Unit gable prism: base 1 x 1 at y = 0, ridge along x at y = 1, z = 0. */
+function prismGeometry() {
+    const A = [-0.5, 0, -0.5], B = [0.5, 0, -0.5], C = [0.5, 0, 0.5], Dd = [-0.5, 0, 0.5], R0 = [-0.5, 1, 0], R1 = [0.5, 1, 0];
+    return flatGeometry([
+        ...quad(Dd, C, R1, R0), // front slope (+z)
+        ...quad(B, A, R0, R1), // back slope (-z)
+        [A, Dd, R0], [C, B, R1], // gables
+        ...quad(A, B, C, Dd), // bottom
+    ]);
+}
+/** Unit hip end: base 1 (x) x 1 (z) at y = 0, the ridge point at (-0.5, 1, 0); slopes down to the +x end and both sides. */
+function hipEndGeometry() {
+    const A = [-0.5, 0, -0.5], B = [0.5, 0, -0.5], C = [0.5, 0, 0.5], Dd = [-0.5, 0, 0.5], R = [-0.5, 1, 0];
+    return flatGeometry([
+        [Dd, C, R], // front slope (+z)
+        [B, A, R], // back slope (-z)
+        [C, B, R], // end slope (+x)
+        ...quad(A, B, C, Dd), // bottom
+    ]);
+}
+/** Unit frustum (mansard): base 1 x 1 at y = 0, top 0.7 x 0.7 at y = 1. */
+function frustumGeometry() {
+    const k = 0.35;
+    const A = [-0.5, 0, -0.5], B = [0.5, 0, -0.5], C = [0.5, 0, 0.5], Dd = [-0.5, 0, 0.5];
+    const a = [-k, 1, -k], b = [k, 1, -k], c = [k, 1, k], d = [-k, 1, k];
+    return flatGeometry([...quad(Dd, C, c, d), ...quad(C, B, b, c), ...quad(B, A, a, b), ...quad(A, Dd, d, a), ...quad(a, b, c, d), ...quad(A, B, C, Dd)]);
+}
+const UNIT = {
+    box: () => { const g = new THREE.BoxGeometry(1, 1, 1); g.translate(0, 0.5, 0); return g; },
+    prism: prismGeometry,
+    hipEnd: hipEndGeometry,
+    frustum: frustumGeometry,
+    cyl: () => { const g = new THREE.CylinderGeometry(0.5, 0.5, 1, 32, 1); g.translate(0, 0.5, 0); return g; },
+};
+function instanced(geo, items, material) {
+    const n = items.length;
+    const aParams = new Float32Array(n * 4), aFacade = new Float32Array(n * 4), aTint = new Float32Array(n * 3);
+    const mesh = new THREE.InstancedMesh(geo, material, n);
+    for (let i = 0; i < n; i++) {
+        const it = items[i];
+        aParams[i * 4] = it.seed;
+        aParams[i * 4 + 1] = it.floors;
+        aParams[i * 4 + 2] = it.floorH;
+        aParams[i * 4 + 3] = it.style;
+        aFacade[i * 4] = it.kind;
+        aFacade[i * 4 + 1] = it.ratio;
+        aFacade[i * 4 + 2] = it.bay;
+        aFacade[i * 4 + 3] = it.lights;
+        aTint[i * 3] = it.tint[0];
+        aTint[i * 3 + 1] = it.tint[1];
+        aTint[i * 3 + 2] = it.tint[2];
+        _p.set(it.x, it.y || 0, it.z);
+        _q.setFromAxisAngle(_up, it.ry || 0);
+        _s.set(it.w, it.h, it.d);
+        _m.compose(_p, _q, _s);
+        mesh.setMatrixAt(i, _m);
+    }
+    geo.setAttribute('aParams', new THREE.InstancedBufferAttribute(aParams, 4));
+    geo.setAttribute('aFacade', new THREE.InstancedBufferAttribute(aFacade, 4));
+    geo.setAttribute('aTint', new THREE.InstancedBufferAttribute(aTint, 3));
+    mesh.instanceMatrix.needsUpdate = true;
+    mesh.computeBoundingBox();
+    mesh.computeBoundingSphere();
+    mesh.castShadow = true;
+    return mesh;
+}
+/** Turn an instance list into InstancedMeshes (one per unit geometry) with the facade attributes.
+ *  The volume's metres go into the instance matrix SCALE (so raycasts, bounds and the
+ *  selection gizmo see the real volumes); the shader reads the size back from the matrix.
+ *  Returns the box mesh; the other geometries are its children. userData.bounds is the union;
+ *  dispose with disposeInstanced(mesh). */
+export function buildInstancedBoxes(list, material) {
+    const by = { box: [], prism: [], hipEnd: [], frustum: [], cyl: [] };
+    for (const it of list)
+        (by[it.geo] || by.box).push(it);
+    const mesh = instanced(UNIT.box(), by.box, material);
+    const bounds = by.box.length ? mesh.boundingBox.clone() : new THREE.Box3();
+    for (const k of ['prism', 'hipEnd', 'frustum', 'cyl']) {
+        if (!by[k].length)
+            continue;
+        const child = instanced(UNIT[k](), by[k], material);
+        mesh.add(child);
+        bounds.union(child.boundingBox);
+    }
+    if (!by.box.length) {
+        mesh.boundingBox = bounds.clone();
+        mesh.boundingSphere = bounds.getBoundingSphere(new THREE.Sphere());
+    }
+    mesh.userData.bounds = bounds;
+    return mesh;
+}
+/** Free every geometry of a buildInstancedBoxes result (the material is shared; dispose it separately). */
+export function disposeInstanced(mesh) {
+    if (!mesh)
+        return;
+    mesh.geometry.dispose();
+    for (const ch of mesh.children)
+        if (ch.geometry)
+            ch.geometry.dispose();
+}
+// ---------------------------------------------------------------------------- material
+export function createUniforms() {
+    return Object.assign(createSunUniforms(), createLampUniforms(), createTextureUniforms('uWall'), {
+        uWallColor: { value: new THREE.Color() },
+        uGlassColor: { value: new THREE.Color() },
+        uGlassReflect: { value: 0.9 },
+        uMullionColor: { value: new THREE.Color() },
+        uRoofColor: { value: new THREE.Color() },
+        uMullionWidth: { value: 0.08 },
+        uLobby: { value: 1 },
+        uLightColor: { value: new THREE.Color() },
+        uCoolLightColor: { value: new THREE.Color() },
+        uLightWarmth: { value: 0.7 },
+        uWindowGlow: { value: 1 },
+        uFlicker: { value: 0.25 },
+        uTime: { value: 0 },
+    });
+}
+/** Per-frame knobs. `tex` = the loaded texture set (or null). */
+export function applyConfig(u, c, tex = undefined) {
+    if (c.wallColor !== undefined)
+        u.uWallColor.value.set(c.wallColor);
+    if (c.glassColor !== undefined)
+        u.uGlassColor.value.set(c.glassColor);
+    if (c.glassReflect !== undefined)
+        u.uGlassReflect.value = c.glassReflect;
+    if (c.mullionColor !== undefined)
+        u.uMullionColor.value.set(c.mullionColor);
+    if (c.roofColor !== undefined)
+        u.uRoofColor.value.set(c.roofColor);
+    if (c.mullionWidth !== undefined)
+        u.uMullionWidth.value = c.mullionWidth;
+    if (c.lobby !== undefined)
+        u.uLobby.value = c.lobby ? 1 : 0;
+    if (c.lightColor !== undefined)
+        u.uLightColor.value.set(c.lightColor);
+    if (c.coolLightColor !== undefined)
+        u.uCoolLightColor.value.set(c.coolLightColor);
+    if (c.lightWarmth !== undefined)
+        u.uLightWarmth.value = c.lightWarmth;
+    if (c.windowGlow !== undefined)
+        u.uWindowGlow.value = c.windowGlow;
+    if (c.flicker !== undefined)
+        u.uFlicker.value = c.flicker;
+    if (tex !== undefined)
+        applyTextureSet(u, 'uWall', tex, c.texture && c.texture.tileSize, c.textureStrength);
+    else if (c.textureStrength !== undefined)
+        u.uWallNormalStrength.value = c.textureStrength;
+}
+export const VERT = /* glsl */ `
+attribute vec4 aParams;
+attribute vec4 aFacade;
+attribute vec3 aTint;
+varying vec3 vLocal;     // metres inside the volume (x,z centred, y from the base)
+varying vec3 vLocalN;    // face normal in the volume's own frame
+varying vec3 vSize;
+varying vec4 vParams;
+varying vec4 vFacade;
+varying vec3 vTint;
+varying vec3 vP;         // world position
+varying vec3 vN;         // world normal
+${GLSL_FOG_VERT_PARS}
+void main() {
+    // The volume's size is the instance matrix scale (metres); the cube is unit.
+    vec3 size = vec3(length(instanceMatrix[0].xyz), length(instanceMatrix[1].xyz), length(instanceMatrix[2].xyz));
+    vLocal = position * size;
+    vLocalN = normal;
+    vSize = size; vParams = aParams; vFacade = aFacade; vTint = aTint;
+    mat4 m = modelMatrix * instanceMatrix;
+    vec4 wp = m * vec4(position, 1.0);
+    vP = wp.xyz;
+    vN = normalize(mat3(m) * normal);
+    vec4 mvPosition = viewMatrix * wp;
+    gl_Position = projectionMatrix * mvPosition;
+    #include <fog_vertex>
+}`;
+export const FRAG = /* glsl */ `
+precision highp float;
+${GLSL_COMMON}
+${glslTextureBlock('uWall')}
+uniform vec3 uWallColor; uniform vec3 uGlassColor; uniform float uGlassReflect; uniform vec3 uMullionColor; uniform vec3 uRoofColor;
+uniform float uMullionWidth; uniform float uLobby;
+uniform vec3 uLightColor; uniform vec3 uCoolLightColor; uniform float uLightWarmth; uniform float uWindowGlow;
+uniform float uFlicker; uniform float uTime;
+varying vec3 vLocal; varying vec3 vLocalN; varying vec3 vSize; varying vec4 vParams; varying vec4 vFacade; varying vec3 vTint;
+varying vec3 vP; varying vec3 vN;
+${GLSL_FOG_PARS}
+
+// Glass: a tinted interior (dark room, or blinds down) under a Fresnel-weighted sky reflection,
+// a sun glint, and at night the lit room. panel is a per-pane hash: real curtain walls are
+// never perfectly coplanar, so each pane reflects a slightly different patch of sky.
+vec3 glassColor(vec3 N, vec3 V, float lit, float roomHash, float panel, float vf) {
+    vec3 R = reflect(-V, N);
+    float fres = 0.04 + 0.96 * pow(1.0 - max(dot(N, V), 0.0), 5.0);
+    float horizon = smoothstep(-0.3, 0.6, R.y + (panel - 0.5) * 0.12);
+    vec3 skyRefl = mix(uGroundAmbient * 1.4, uSkyAmbient * 2.6 + uSunColor * 0.10, horizon);
+    float blinds = step(fract(roomHash * 13.7), 0.14);
+    vec3 interior = mix(uGlassColor * 0.22, vec3(0.55, 0.53, 0.5) * 0.6, blinds) * (uSkyAmbient + uSunColor * 0.3);
+    float k = clamp(fres * uGlassReflect + 0.42 * uGlassReflect, 0.0, 1.0);
+    vec3 col = mix(interior, skyRefl * uGlassColor * 1.9 * (0.94 + 0.12 * panel), k);
+    float glint = pow(max(dot(R, uSunDir), 0.0), 500.0) * 1.2;
+    col += uSunColor * glint * uGlassReflect;
+    // The lit room: warm / cool coin, brighter toward the ceiling, dimmed by blinds.
+    vec3 room = mix(uCoolLightColor, uLightColor, step(roomHash, uLightWarmth));
+    float ceiling = 0.65 + 0.45 * vf;
+    col += room * (lit * uNight * uWindowGlow * 0.75 * ceiling * (0.5 + 0.5 * fract(roomHash * 7.31)) * (1.0 - 0.55 * blinds));
+    return col;
+}
+
+// 1 inside (x < e), anti-aliased over w.
+float inside(float x, float e, float w) { return 1.0 - smoothstep(e - w, e + w, x); }
+
+void main() {
+    vec3 N = normalize(vN);
+    vec3 V = normalize(cameraPosition - vP);
+    vec3 n = vLocalN;
+    float styleRaw = floor(vParams.w + 0.5);
+    float round = step(9.5, styleRaw);
+    float style = styleRaw - round * 10.0;
+    // The seed is an integer per instance; snap it, because a varying is interpolated and a
+    // hash of a value off by 1e-5 is a different value (that reads as per-pixel confetti).
+    float seed = floor(vParams.x + 0.5);
+    float mark = floor(vFacade.x + 0.5);          // on solid styles: the roof marking
+    bool solid = style > 0.5 && style < 1.5;
+    bool roofStyle = style > 2.5 && style < 3.5;
+    bool crown = style > 3.5;
+    // Roof pieces are coloured by their world slope (a gable or mansard face is still a roof).
+    bool topFace = roofStyle ? (N.y > 0.2) : (n.y > 0.5);
+    vec3 col;
+    if (topFace || solid || roofStyle || crown || n.y < -0.5) {
+        // Roof top, parapet / plant boxes, roof pieces, crown band: wall or roof colour with the texture.
+        vec3 T = abs(n.y) > 0.5 ? vec3(1.0, 0.0, 0.0) : normalize(cross(vec3(0.0, 1.0, 0.0), N));
+        vec3 B = abs(n.y) > 0.5 ? vec3(0.0, 0.0, 1.0) : vec3(0.0, 1.0, 0.0);
+        vec2 uvM = abs(n.y) > 0.5 ? vLocal.xz : (abs(n.x) > 0.5 ? vec2(vLocal.z, vLocal.y) : vec2(vLocal.x, vLocal.y));
+        float rough;
+        vec3 Nb = N;
+        vec3 mul = uWallSample(uvM + seed, Nb, T, B, rough);
+        bool useRoof = roofStyle ? topFace : (n.y > 0.5 && !solid && !crown);
+        vec3 base = useRoof ? uRoofColor : uWallColor * vTint;
+        float grain = 0.92 + 0.16 * hash21(floor(uvM * 2.0) + seed);
+        float ao = n.y > 0.5 ? 1.0 : 0.65 + 0.35 * smoothstep(0.0, 1.0, vLocal.y / max(vSize.y, 0.01));
+        vec3 albedo = base * mul * grain;
+        if (roofStyle && topFace && mark > 1.5) {
+            // Green roof: two greens broken by cells and a soft gradient, no texture relief.
+            vec2 q = vLocal.xz + seed;
+            albedo = mix(vec3(0.16, 0.30, 0.09), vec3(0.28, 0.42, 0.14), hash21(floor(q * 1.7)) * 0.6 + 0.2 * sin(q.x * 0.7) * cos(q.y * 0.5));
+            rough = 0.95; Nb = N;
+        }
+        if (roofStyle && topFace && mark > 0.5 && mark < 1.5) {
+            // Helipad: a dark disc, a white ring and an H.
+            vec2 q = vLocal.xz / max(vSize.x * 0.5, 0.01);
+            float r = length(q);
+            float w = fwidth(r) + 0.004;
+            float ring = inside(r, 0.95, w) * (1.0 - inside(r, 0.86, w));
+            float H = inside(abs(abs(q.x) - 0.33), 0.09, w) * inside(abs(q.y), 0.45, w) + inside(abs(q.y), 0.08, w) * inside(abs(q.x), 0.33, w);
+            float paint = clamp(ring + H, 0.0, 1.0);
+            albedo = mix(vec3(0.21, 0.21, 0.22), vec3(0.92), paint);
+            rough = 0.8; Nb = N;
+        }
+        col = shadeSurface(albedo, Nb, vP, V, rough, ao);
+        if (crown) {
+            // Crown band: pale by day, an emissive band at night (bloom picks it up).
+            vec3 lightC = mix(uCoolLightColor, uLightColor, uLightWarmth);
+            col = shadeSurface(mix(uWallColor * vTint, lightC, 0.5), N, vP, V, 0.5, 1.0) + lightC * uNight * uWindowGlow * 1.6;
+        }
+    } else {
+        // A facade face: u along the face (from its left corner; around the circumference on a
+        // cylinder), v up from the base.
+        float faceW, u;
+        if (round > 0.5) {
+            faceW = 3.14159265 * vSize.x;
+            u = (atan(vLocal.z, vLocal.x) / 6.2831853 + 0.5) * faceW;
+        } else {
+            faceW = abs(n.x) > 0.5 ? vSize.z : vSize.x;
+            u = abs(n.x) > 0.5 ? (vLocal.z * sign(n.x) + vSize.z * 0.5) : (vLocal.x * -sign(n.z) + vSize.x * 0.5);
+        }
+        float v = vLocal.y;
+        float floorH = vParams.z;
+        float lobbyH = (style < 0.5 && uLobby > 0.5) ? floorH * 1.6 : floorH;
+        // Floors: the lobby counts as floor 0, the rest are floorH each above it.
+        float fIdx = v < lobbyH ? 0.0 : 1.0 + floor((v - lobbyH) / floorH);
+        float fBase = fIdx < 0.5 ? 0.0 : lobbyH + (fIdx - 1.0) * floorH;
+        float fH = fIdx < 0.5 ? lobbyH : floorH;
+        float vf = (v - fBase) / fH;
+        // Bays fit the face exactly.
+        float nBays = max(1.0, floor(faceW / vFacade.z + 0.5));
+        float bayW = faceW / nBays;
+        float bIdx = floor(u / bayW);
+        float uf = (u - bIdx * bayW) / bayW;
+        float kind = vFacade.x;
+        float ratio = vFacade.y;
+        float mw = uMullionWidth;
+        // Pixel-size terms in bay / floor fractions, for anti-aliasing.
+        float wu = fwidth(uf), wv = fwidth(vf);
+        float glass = 0.0, mullion = 0.0;
+        float wallMul = 1.0;        // tone of the wall where it is not glass: trims lighter, recesses darker
+        float door = 0.0;           // industrial roller doors
+        bool lobby = fIdx < 0.5 && style < 0.5 && uLobby > 0.5;
+        if (lobby) {
+            // Lobby: full-height glass, a frame at the floor line and thicker mullions per bay.
+            glass = 1.0;
+            float frameM = (mw * 2.0) / bayW, frameV = 0.25 / fH;
+            mullion = max(1.0 - bandAA(uf, frameM, 1.0 - frameM), 1.0 - bandAA(vf, frameV, 1.0 - 0.12 / fH));
+            // Doors: a darker pair in the middle bay, drawn as mullion colour.
+            float mid = step(abs(bIdx + 0.5 - nBays * 0.5), 0.75);
+            mullion = max(mullion, mid * (1.0 - bandAA(abs(uf - 0.5), 0.012, 1.0)));
+        } else if (kind < 0.5) {
+            // Curtain wall: glass above a spandrel band; mullions on every bay and floor edge.
+            float spandrel = clamp(1.0 - ratio, 0.08, 0.7);
+            glass = bandAA(vf, spandrel, 1.0);
+            float mU = mw / bayW, mV = mw / fH;
+            mullion = max(1.0 - bandAA(uf, mU, 1.0 - mU), 1.0 - bandAA(vf, mV, 1.0 - mV));
+            // A thin transom line at the spandrel top reads as the slab edge.
+            mullion = max(mullion, bandAA(vf, spandrel - mV, spandrel + mV));
+        } else if (kind < 1.5) {
+            // Punched windows: one opening per bay, sill at 0.22, head at 0.82 of the floor.
+            float halfW = clamp(ratio, 0.15, 0.95) * 0.45;
+            float inX = bandAA(uf, 0.5 - halfW, 0.5 + halfW);
+            float inY = bandAA(vf, 0.22, 0.82);
+            glass = inX * inY;
+            // Frame: the opening's rim, and a reveal shadow on the side away from the sun.
+            float fU = 0.06 / bayW, fV = 0.06 / fH;
+            float inner = bandAA(uf, 0.5 - halfW + fU, 0.5 + halfW - fU) * bandAA(vf, 0.22 + fV, 0.82 - fV);
+            mullion = glass - inner;
+            glass = inner;
+        } else if (kind < 2.5) {
+            // Ribbon: a horizontal glass band per floor, thin mullions every bay.
+            float band = clamp(ratio, 0.15, 0.95) * 0.62;
+            glass = bandAA(vf, 0.3, 0.3 + band);
+            float mU = mw * 0.8 / bayW;
+            mullion = glass * (1.0 - bandAA(uf, mU, 1.0 - mU));
+            mullion = max(mullion, bandAA(vf, 0.3 - 0.02 / fH, 0.3 + 0.02 / fH) + bandAA(vf, 0.3 + band - 0.02 / fH, 0.3 + band + 0.02 / fH));
+        } else if (kind < 3.5) {
+            // Brick: a punched window per bay with a lintel above and a sill below, in a running-bond wall.
+            float halfW = clamp(ratio, 0.15, 0.95) * 0.4;
+            float fU = 0.07 / bayW, fV = 0.07 / fH;
+            float open = bandAA(uf, 0.5 - halfW, 0.5 + halfW) * bandAA(vf, 0.2, 0.78);
+            float inner = bandAA(uf, 0.5 - halfW + fU, 0.5 + halfW - fU) * bandAA(vf, 0.2 + fV, 0.78 - fV);
+            mullion = open - inner; glass = inner;
+            float trim = bandAA(uf, 0.5 - halfW - fU, 0.5 + halfW + fU) * (bandAA(vf, 0.78, 0.84) + bandAA(vf, 0.16, 0.2));
+            // Running bond: courses of 7.5 cm, bricks of 23 cm, darker mortar; fades out before it aliases.
+            float row = floor(v / 0.075), cy = fract(v / 0.075), cx = fract((u + mod(row, 2.0) * 0.115) / 0.23);
+            float mortar = max(step(cy, 0.12), step(cx, 0.045));
+            float tone = 0.9 + 0.2 * hash21(vec2(floor((u + mod(row, 2.0) * 0.115) / 0.23), row) + seed);
+            float fade = 1.0 - smoothstep(0.015, 0.05, fwidth(v));
+            wallMul = mix(1.0, mix(tone, 0.68, mortar), fade);
+            wallMul = mix(wallMul, 1.25, clamp(trim, 0.0, 1.0));
+        } else if (kind < 4.5) {
+            // Balconies: a recessed balcony per bay — slab, railing, the glass door behind it.
+            float band = clamp(ratio, 0.15, 0.95) * 0.5;
+            float span = bandAA(uf, 0.1, 0.9);
+            glass = bandAA(vf, 0.45, 0.45 + band) * bandAA(uf, 0.14, 0.86);
+            float recess = bandAA(vf, 0.1, 0.45) * span;
+            float slab = bandAA(vf, 0.0, 0.1) * bandAA(uf, 0.06, 0.94);
+            float railFade = 1.0 - smoothstep(0.03, 0.08, fwidth(u));
+            float rails = recess * (1.0 - bandAA(fract(u / 0.16), 0.14, 0.86)) * railFade;
+            float topRail = bandAA(vf, 0.41, 0.45) * span;
+            mullion = max(glass * (1.0 - bandAA(uf, 0.14 + mw / bayW, 0.86 - mw / bayW)), max(rails, topRail));
+            wallMul = mix(1.0, 0.5, recess);
+            wallMul = mix(wallMul, 0.82, slab);
+        } else if (kind < 5.5) {
+            // Concrete panels: a small window per panel, dark joints on every panel edge, a tone per panel.
+            float halfW = clamp(ratio, 0.15, 0.95) * 0.35;
+            float fU = 0.06 / bayW, fV = 0.06 / fH;
+            float open = bandAA(uf, 0.5 - halfW, 0.5 + halfW) * bandAA(vf, 0.3, 0.78);
+            float inner = bandAA(uf, 0.5 - halfW + fU, 0.5 + halfW - fU) * bandAA(vf, 0.3 + fV, 0.78 - fV);
+            mullion = open - inner; glass = inner;
+            float jU = 0.03 / bayW, jV = 0.03 / fH;
+            float joint = max(1.0 - bandAA(uf, jU, 1.0 - jU), 1.0 - bandAA(vf, jV, 1.0 - jV));
+            float tone = 0.93 + 0.14 * hash21(vec2(bIdx, fIdx) + seed);
+            wallMul = mix(tone, 0.55, joint);
+        } else if (kind < 6.5) {
+            // Glass fins: near-full glass with a vertical fin on every bay edge and a slab line.
+            glass = bandAA(vf, 0.07, 1.0);
+            float finU = 0.15 / bayW;
+            float fin = 1.0 - bandAA(uf, finU, 1.0 - finU);
+            mullion = max(fin, bandAA(vf, 0.0, 0.07));
+        } else {
+            // Industrial: tall narrow windows, a roller door every third ground-floor bay, a dark eaves band.
+            float halfW = clamp(ratio, 0.15, 0.95) * 0.3;
+            float fU = 0.05 / bayW, fV = 0.05 / fH;
+            float open = bandAA(uf, 0.5 - halfW, 0.5 + halfW) * bandAA(vf, 0.35, 0.86);
+            float inner = bandAA(uf, 0.5 - halfW + fU, 0.5 + halfW - fU) * bandAA(vf, 0.35 + fV, 0.86 - fV);
+            mullion = open - inner; glass = inner;
+            if (fIdx < 0.5 && mod(bIdx, 3.0) < 0.5) {
+                door = bandAA(uf, 0.12, 0.88) * bandAA(vf, 0.0, 0.8);
+                glass *= 1.0 - door; mullion *= 1.0 - door;
+            }
+            float eaves = bandAA(vf, 0.9, 1.0) * step(vParams.y - 0.5, fIdx);
+            float jU = 0.02 / bayW;
+            wallMul = mix(1.0, 0.8, max(eaves, 1.0 - bandAA(uf, jU, 1.0 - jU)));
+        }
+        mullion = clamp(mullion, 0.0, 1.0);
+        // Wall sample (texture in metres along the face), bumped normal for the wall only.
+        vec3 T = round > 0.5 ? normalize(cross(vec3(0.0, 1.0, 0.0), N)) : normalize(cross(vec3(0.0, 1.0, 0.0), N));
+        vec3 B = vec3(0.0, 1.0, 0.0);
+        float rough;
+        vec3 Nw = N;
+        vec3 mul = uWallSample(vec2(u, v) + seed, Nw, T, B, rough);
+        float ao = 0.6 + 0.4 * smoothstep(0.0, 2.5, v);
+        vec3 wallAlbedo = uWallColor * vTint * mul * wallMul;
+        vec3 wall = shadeSurface(wallAlbedo, Nw, vP, V, rough, ao);
+        // Window id -> lit coin and room hash, stable per building (seed) and face.
+        float faceId = round > 0.5 ? 1.0 : (n.x > 0.5 ? 1.0 : n.x < -0.5 ? 2.0 : n.z > 0.5 ? 3.0 : 4.0);
+        // Rooms span 1-3 bays (hashed per floor), so lit windows come in runs, not confetti.
+        float roomBays = 1.0 + floor(hash21(vec2(fIdx, faceId + seed)) * 3.0);
+        vec2 wid = vec2(floor(bIdx / roomBays) + faceId * 97.0, fIdx + seed);
+        // Each room has its own slow clock (20-80 s at flicker 1, slower below); the lit coin is
+        // re-rolled once per period, so at any moment only a few rooms switch, like a real city.
+        float period = (20.0 + 60.0 * hash21(wid + 5.3)) / max(uFlicker, 0.001);
+        float epoch = uFlicker > 0.001 ? floor((uTime + hash21(wid + 9.1) * period) / period) : 0.0;
+        float lit = lobby ? 0.45 : step(hash21(wid + epoch * 0.731), vFacade.w);
+        float roomHash = hash21(wid + 31.7);
+        float panel = hash21(vec2(bIdx + faceId * 31.0, fIdx + seed * 0.5));
+        vec3 glassCol = glassColor(N, V, lit, roomHash, panel, vf);
+        vec3 mullionCol = shadeSurface(uMullionColor, N, vP, V, 0.45, ao);
+        col = mix(wall, glassCol, glass);
+        col = mix(col, mullionCol, mullion);
+        if (door > 0.0) {
+            // A roller door: painted metal with horizontal slats.
+            float slat = 0.85 + 0.15 * bandAA(fract(v / 0.3), 0.15, 1.0);
+            col = mix(col, shadeSurface(mix(uMullionColor, uWallColor * vTint, 0.35) * slat, N, vP, V, 0.5, ao), door);
+        }
+        // Contact shadow at the pavement and under the slab edge of each floor.
+        col *= 0.75 + 0.25 * smoothstep(0.0, 1.2, v);
+    }
+${GLSL_OUT}
+}`;
+export function createMaterial(u) {
+    return new THREE.ShaderMaterial({ uniforms: Object.assign(THREE.UniformsUtils.clone(THREE.UniformsLib.fog), u), vertexShader: VERT, fragmentShader: FRAG, fog: true });
+}
+// ---------------------------------------------------------------------------- lab build
+/** Lab entry: build(u, c) -> { object, mesh, apply, rebuild, update, dispose }. */
+export function build(u, c) {
+    const group = new THREE.Group();
+    const mat = createMaterial(u);
+    let mesh = null;
+    const state = { tex: null };
+    const rebuild = (cfg) => {
+        if (mesh) {
+            group.remove(mesh);
+            disposeInstanced(mesh);
+        }
+        const list = addBuilding([], cfg, 0, 0, 0, [1, 1, 1]);
+        mesh = buildInstancedBoxes(list, mat);
+        group.add(mesh);
+    };
+    const setTexture = (cfg) => {
+        const maps = cfg.texture && cfg.texture.maps;
+        if (maps && maps.color) {
+            state.tex = loadTextureSet(maps);
+            state.tex.ready.then(() => applyConfig(u, cfg, state.tex));
+        }
+        else
+            state.tex = null;
+        applyConfig(u, cfg, state.tex && state.tex.color ? state.tex : null);
+    };
+    rebuild(c);
+    setTexture(c);
+    return {
+        object: group,
+        get mesh() { return mesh; },
+        materials: [mat],
+        uniformSets: [u],
+        apply(cfg) { applyConfig(u, cfg, undefined); },
+        rebuild(cfg) { rebuild(cfg); setTexture(cfg); },
+        bounds() { return mesh ? mesh.userData.bounds.clone() : new THREE.Box3(); },
+        update(dt) { u.uTime.value += dt; },
+        dispose() { disposeInstanced(mesh); mat.dispose(); },
+    };
+}