@3driseai/3drise-viewer 0.1.42 → 0.1.44

package/dist/components/urban/urbanCore.js

@@ -0,0 +1,928 @@
+// =============================================================================
+// urbanCore — the shared core of the urban family (type 'urban': building, block, road, streetFurniture, skyline, plaza, junction, traffic, signage, parkingLot, park, streetGrid)
+// =============================================================================
+// ONE util imported by every urban component (emitted from Claude outputs/urban-lab/common.mjs —
+// edit there and re-emit, so the lab and the repo stay the same code).
+//
+// What is in here and why:
+//   lamp list   Street lamps carry no THREE light. Every lamp (a streetFurniture lamp, a
+//               road's own lamps, later lamp layouts) registers its world position, colour,
+//               radius and intensity in one registry. Surfaces the family owns (road, paving,
+//               facades) GATHER the lamps that reach their bounds into a bounded uniform array
+//               (MAX_LAMPS) and light themselves in their fragment shader. Adding a lamp
+//               recompiles nothing; the registry may hold 256+, a surface loops over <= 48.
+//   sun / night One sun block shared by every urban shader (direction, beam colour, sky and
+//               ground ambient) and a night factor derived from the sun's height; in the app
+//               the component fills it from useCloudSun, the lab from its hour slider.
+//   textures    A texture set from the library ({ set, maps, tileSize }) -> colour / normal /
+//               roughness textures plus the colour map's linear mean, so a knob colour decides
+//               the albedo and the scan only adds grain (the terrain's rule).
+//   lamp fixture One generative lamp-post geometry used by streetFurniture (kind lamp) and by
+//               a road's own lamps, with a vertex flag for the emissive head.
+import * as THREE from 'three';
+export const MAX_LAMPS = 48;
+export function mulberry32(a) {
+    return function () {
+        a |= 0;
+        a = (a + 0x6d2b79f5) | 0;
+        let t = Math.imul(a ^ (a >>> 15), 1 | a);
+        t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
+        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+    };
+}
+export const clamp01 = (x) => Math.min(1, Math.max(0, x));
+// ---------------------------------------------------------------------------- lamp registry
+// A lamp: { id, position: THREE.Vector3 (world), color: THREE.Color, radius (world), intensity, on,
+// baseRadius (the object's own metres), scale (the object's world scale) }.
+// Components own their entries (register on mount, place them with placeLamps when their
+// matrixWorld changes, unregister on unmount). `version` bumps on every change so a consumer knows to regather.
+// A lamp scales with its object like everything else in the scene: its reach is baseRadius × scale
+// and its light falls off over the object's own metres (distance ÷ scale), so a city scaled down to
+// a model looks the same, only smaller.
+export const lampRegistry = { lamps: [], version: 0 };
+export function registerLamp(lamp) {
+    if (lamp.baseRadius === undefined)
+        lamp.baseRadius = lamp.radius;
+    if (lamp.scale === undefined)
+        lamp.scale = 1;
+    lampRegistry.lamps.push(lamp);
+    lampRegistry.version++;
+    return lamp;
+}
+export function unregisterLamp(lamp) {
+    const i = lampRegistry.lamps.indexOf(lamp);
+    if (i >= 0) {
+        lampRegistry.lamps.splice(i, 1);
+        lampRegistry.version++;
+    }
+}
+export function touchLamps() { lampRegistry.version++; }
+/**
+ * Set lamps' colour / intensity / radius (undefined = leave it) and bump the lamp list ONLY when a
+ * value really changed. An object's apply runs every frame while any of its knobs animates (the
+ * config driver pushes the whole merged config); a bump per frame makes every lamp-lit surface in
+ * the scene re-gather and every lamp field re-bake each frame (a city fell to 7 fps). Returns
+ * whether anything changed.
+ */
+const _lampColor = new THREE.Color();
+export function setLamps(lamps, color = undefined, intensity = undefined, radius = undefined) {
+    let changed = false;
+    if (color !== undefined)
+        _lampColor.set(color);
+    for (const L of lamps) {
+        if (color !== undefined && !L.color.equals(_lampColor)) {
+            L.color.copy(_lampColor);
+            changed = true;
+        }
+        if (intensity !== undefined && L.intensity !== intensity) {
+            L.intensity = intensity;
+            changed = true;
+        }
+        if (radius !== undefined && L.baseRadius !== radius) {
+            L.baseRadius = radius;
+            L.radius = radius * (L.scale || 1);
+            changed = true;
+        }
+    }
+    if (changed)
+        touchLamps();
+    return changed;
+}
+/**
+ * Place lamps through an object's world matrix: each lamp at its local head (`locals[i]`), its reach
+ * and falloff scaled by the matrix's scale. Call when the matrix changed, then touchLamps().
+ */
+export function placeLamps(lamps, locals, matrixWorld) {
+    const s = matrixWorld.getMaxScaleOnAxis() || 1;
+    for (let i = 0; i < lamps.length; i++) {
+        const L = lamps[i];
+        L.position.copy(locals[i]).applyMatrix4(matrixWorld);
+        if (L.baseRadius === undefined)
+            L.baseRadius = L.radius;
+        L.scale = s;
+        L.radius = L.baseRadius * s;
+    }
+}
+let _blankField = null;
+function blankFieldTexture() {
+    if (!_blankField) {
+        _blankField = new THREE.DataTexture(new Uint8Array(4), 1, 1, THREE.RGBAFormat);
+        _blankField.needsUpdate = true;
+    }
+    return _blankField;
+}
+export function createLampUniforms() {
+    const pos = [], col = [];
+    const aim = [];
+    for (let i = 0; i < MAX_LAMPS; i++) {
+        pos.push(new THREE.Vector4(0, 0, 0, 1));
+        col.push(new THREE.Vector4(1, 1, 1, 0));
+        aim.push(new THREE.Vector4(0, 0, 0, 0));
+    }
+    // uLampTop: the highest point any gathered lamp can reach (world y); fragments above it skip the loop.
+    // uLampField*: a baked top-down lamp texture (createLampField) used INSTEAD of the list when on.
+    // uLampAims: per lamp (aim direction xyz, cos of the beam's outer half-angle); w > 0 a projector — an
+    // aimed long-throw floodlight (stadium towers); w <= 0 a street lamp (an omni pool under the head), -w
+    // its object's world scale (its falloff is over the object's own metres).
+    return {
+        uLamps: { value: pos }, uLampColors: { value: col }, uLampAims: { value: aim }, uLampCount: { value: 0 }, uLampTop: { value: 0 },
+        uLampField: { value: blankFieldTexture() }, uLampFieldRect: { value: new THREE.Vector4(0, 0, 1, 1) }, uLampFieldOn: { value: 0 },
+    };
+}
+const _d = new THREE.Vector3(), _a = new THREE.Vector3();
+/**
+ * Fill a surface's lamp uniforms with the registry lamps whose pool reaches `bounds`
+ * (a world Box3), nearest first when more than MAX_LAMPS qualify. Positions are WORLD
+ * space, like the shaders' vP (pass invWorld only for a shader that lights in local space).
+ */
+export function gatherLamps(u, bounds, invWorld = null) {
+    const list = lampRegistry.lamps;
+    const hits = [];
+    for (let i = 0; i < list.length; i++) {
+        const L = list[i];
+        if (!L.on)
+            continue;
+        bounds.clampPoint(L.position, _d);
+        const dist = _d.distanceTo(L.position);
+        if (dist < L.radius)
+            hits.push([dist, L]);
+    }
+    if (hits.length > MAX_LAMPS)
+        hits.sort((a, b) => a[0] - b[0]);
+    const n = Math.min(hits.length, MAX_LAMPS);
+    let top = -1e9;
+    for (let i = 0; i < n; i++) {
+        const L = hits[i][1];
+        _d.copy(L.position);
+        if (invWorld)
+            _d.applyMatrix4(invWorld);
+        u.uLamps.value[i].set(_d.x, _d.y, _d.z, L.radius);
+        u.uLampColors.value[i].set(L.color.r, L.color.g, L.color.b, L.intensity);
+        if (u.uLampAims) {
+            if (L.aim) {
+                _a.copy(L.aim);
+                if (invWorld)
+                    _a.transformDirection(invWorld);
+                u.uLampAims.value[i].set(_a.x, _a.y, _a.z, L.spread || 0.8);
+            }
+            else
+                u.uLampAims.value[i].set(0, 0, 0, -(L.scale || 1));
+        }
+        top = Math.max(top, _d.y + L.radius);
+    }
+    u.uLampCount.value = n;
+    u.uLampTop.value = n ? top : -1e9;
+    return n;
+}
+// ---------------------------------------------------------------------------- lamp field
+// For a large flat set of surfaces (a whole street grid) a per-surface list of 48 lamps does
+// not fit, and it forces one material per piece. A lamp field is the lamps' light on the
+// ground, baked top-down into one texture over the set's world rectangle: every surface
+// shares it, so the pieces can merge into a few meshes, and the fragment pays one fetch
+// instead of a 48-lamp loop. Stored sqrt-encoded in RGBA8 (fine in the dark tails, no
+// float-filtering extension needed). Walls get a share by their normal (see lampLight).
+const FIELD_MAX = 768, FIELD_TEXEL = 0.5, FIELD_RANGE = 4; // max side, finest metres per texel, stored range
+export function createLampField() {
+    const texture = new THREE.DataTexture(new Uint8Array(4), 1, 1, THREE.RGBAFormat);
+    texture.magFilter = THREE.LinearFilter;
+    texture.minFilter = THREE.LinearFilter;
+    texture.generateMipmaps = false;
+    texture.wrapS = texture.wrapT = THREE.ClampToEdgeWrapping;
+    return { texture, rect: new THREE.Vector4(0, 0, 1, 1), acc: null, w: 0, h: 0 };
+}
+/** Point a material's lamp uniforms at a field (the uniforms take the field's texture and rect objects). */
+export function attachLampField(u, field) {
+    if (!u || !u.uLampField)
+        return;
+    u.uLampField.value = field.texture;
+    u.uLampFieldRect.value = field.rect;
+    u.uLampFieldOn.value = 1;
+}
+/** Bake every registry lamp whose pool reaches `bounds` (world Box3) into the field. Same falloff as lampLight, receiver facing up. */
+export function bakeLampField(field, bounds) {
+    const x0 = bounds.min.x - 2, z0 = bounds.min.z - 2;
+    const ex = bounds.max.x - bounds.min.x + 4, ez = bounds.max.z - bounds.min.z + 4;
+    // the finest texel follows the lamps' scale (a city scaled down keeps its pools sharp)
+    let sMin = Infinity;
+    for (const L of lampRegistry.lamps)
+        if (L.on)
+            sMin = Math.min(sMin, L.scale || 1);
+    const texel = Math.max(FIELD_TEXEL * (Number.isFinite(sMin) ? sMin : 1), Math.max(ex, ez) / FIELD_MAX);
+    const w = Math.max(2, Math.ceil(ex / texel)), h = Math.max(2, Math.ceil(ez / texel));
+    if (!field.acc || field.w !== w || field.h !== h) {
+        field.acc = new Float32Array(w * h * 3);
+        field.texture.dispose();
+        field.texture.image = { data: new Uint8Array(w * h * 4), width: w, height: h };
+        field.w = w;
+        field.h = h;
+    }
+    else
+        field.acc.fill(0);
+    // Texel centres sit at x0 + (i + 0.5) * texel; the shader maps world xz to uv with the same rect.
+    field.rect.set(x0, z0, w * texel, h * texel);
+    const acc = field.acc, gy = bounds.min.y + 0.05;
+    for (const L of lampRegistry.lamps) {
+        if (!L.on || L.intensity <= 0)
+            continue;
+        const p = L.position, R = L.radius;
+        if (p.x < x0 - R || p.z < z0 - R || p.x > x0 + w * texel + R || p.z > z0 + h * texel + R)
+            continue;
+        const i0 = Math.max(0, Math.floor((p.x - R - x0) / texel)), i1 = Math.min(w - 1, Math.ceil((p.x + R - x0) / texel));
+        const j0 = Math.max(0, Math.floor((p.z - R - z0) / texel)), j1 = Math.min(h - 1, Math.ceil((p.z + R - z0) / texel));
+        const dy = p.y - gy, cr = L.color.r * L.intensity * 4, cg = L.color.g * L.intensity * 4, cb = L.color.b * L.intensity * 4;
+        const fs = 0.06 / ((L.scale || 1) * (L.scale || 1)); // falloff over the object's own metres
+        const A = L.aim, c0 = L.spread || 0.8, c1 = c0 + (1 - c0) * 0.45;
+        for (let j = j0; j <= j1; j++) {
+            const dz = p.z - (z0 + (j + 0.5) * texel);
+            for (let i = i0; i <= i1; i++) {
+                const dx = p.x - (x0 + (i + 0.5) * texel);
+                const r2 = dx * dx + dy * dy + dz * dz, r = Math.sqrt(r2), x = r / R;
+                if (x >= 1)
+                    continue;
+                let win = 1 - x * x * x * x;
+                win *= win;
+                const ly = dy / Math.max(r, 1e-3);
+                if (A) {
+                    const dc = -(A.x * dx + A.y * dy + A.z * dz) / Math.max(r, 1e-3);
+                    const ts = clamp01((dc - c0) / (c1 - c0)), spot = ts * ts * (3 - 2 * ts);
+                    const kp = win * spot * (0.35 + 0.65 * Math.max(ly, 0)) / (1 + x * x * 3);
+                    if (kp > 0) {
+                        const o = (j * w + i) * 3;
+                        acc[o] += cr * kp;
+                        acc[o + 1] += cg * kp;
+                        acc[o + 2] += cb * kp;
+                    }
+                    continue;
+                }
+                const t = clamp01((ly - 0.1) / 0.6), cone = t * t * (3 - 2 * t);
+                const k = win * Math.max(ly, 0) * cone / (1 + r2 * fs);
+                if (k <= 0)
+                    continue;
+                const o = (j * w + i) * 3;
+                acc[o] += cr * k;
+                acc[o + 1] += cg * k;
+                acc[o + 2] += cb * k;
+            }
+        }
+    }
+    const data = field.texture.image.data;
+    for (let i = 0, n = w * h; i < n; i++) {
+        data[i * 4] = Math.round(255 * Math.sqrt(Math.min(acc[i * 3] / FIELD_RANGE, 1)));
+        data[i * 4 + 1] = Math.round(255 * Math.sqrt(Math.min(acc[i * 3 + 1] / FIELD_RANGE, 1)));
+        data[i * 4 + 2] = Math.round(255 * Math.sqrt(Math.min(acc[i * 3 + 2] / FIELD_RANGE, 1)));
+        data[i * 4 + 3] = 255;
+    }
+    field.texture.needsUpdate = true;
+}
+// ---------------------------------------------------------------------------- sun block
+export function createSunUniforms() {
+    return {
+        uSunDir: { value: new THREE.Vector3(0.35, 0.6, 0.72).normalize() },
+        uSunColor: { value: new THREE.Color(1.0, 0.95, 0.88) },
+        uSkyAmbient: { value: new THREE.Color(0.35, 0.42, 0.55) },
+        uGroundAmbient: { value: new THREE.Color(0.18, 0.16, 0.14) },
+        uNight: { value: 0 },
+    };
+}
+/** Night factor from the sun: lights come on through civil dusk (sun 2 deg above to 6 deg below). */
+export function nightFromSun(sunDirY) {
+    return clamp01((0.035 - sunDirY) / (0.035 + 0.105));
+}
+/**
+ * sun = { direction, color, skyAmbient, groundAmbient } (the useCloudSun state) and the
+ * object's lighting mode: 'auto' follows the sun, 'day' / 'night' force it.
+ */
+export function applySun(u, sun, lighting = 'auto') {
+    u.uSunDir.value.copy(sun.direction);
+    u.uSunColor.value.copy(sun.color);
+    u.uSkyAmbient.value.copy(sun.skyAmbient);
+    u.uGroundAmbient.value.copy(sun.groundAmbient);
+    const n = lighting === 'night' ? 1 : lighting === 'day' ? 0 : nightFromSun(sun.direction.y);
+    u.uNight.value = n;
+}
+// ---------------------------------------------------------------------------- GLSL chunks
+export const GLSL_COMMON = /* glsl */ `
+uniform vec3 uSunDir;
+uniform vec3 uSunColor;
+uniform vec3 uSkyAmbient;
+uniform vec3 uGroundAmbient;
+uniform float uNight;
+uniform vec4 uLamps[${MAX_LAMPS}];
+uniform vec4 uLampColors[${MAX_LAMPS}];
+uniform vec4 uLampAims[${MAX_LAMPS}];
+uniform int uLampCount;
+uniform float uLampTop;
+uniform sampler2D uLampField;
+uniform vec4 uLampFieldRect;
+uniform float uLampFieldOn;
+
+float hash11(float p) { p = fract(p * 0.1031); p *= p + 33.33; p *= p + p; return fract(p); }
+float hash21(vec2 p) { vec3 p3 = fract(vec3(p.xyx) * 0.1031); p3 += dot(p3, p3.yzx + 33.33); return fract((p3.x + p3.y) * p3.z); }
+float vnoise21(vec2 p) { vec2 i = floor(p), f = fract(p); f = f * f * (3.0 - 2.0 * f); return mix(mix(hash21(i), hash21(i + vec2(1.0, 0.0)), f.x), mix(hash21(i + vec2(0.0, 1.0)), hash21(i + vec2(1.0, 1.0)), f.x), f.y); }
+float hash31(vec3 p) { p = fract(p * 0.1031); p += dot(p, p.zyx + 31.32); return fract((p.x + p.y) * p.z); }
+
+// Irradiance from the gathered lamps. Each lamp is a downward-facing head: a smooth
+// window to its radius, inverse-square falloff softened near the head, a cosine cone so
+// it pools on the ground and only grazes walls, Lambert on the receiver. Scaled by the
+// night factor so pools fade in with dusk.
+vec3 lampLight(vec3 P, vec3 N) {
+    vec3 acc = vec3(0.0);
+    if (uNight < 0.002) return acc;
+    // A baked lamp field (a street grid): the ground's light at this xz, decoded; walls take a share.
+    if (uLampFieldOn > 0.5) {
+        vec3 e = texture2D(uLampField, (P.xz - uLampFieldRect.xy) / uLampFieldRect.zw).rgb;
+        return e * e * ${FIELD_RANGE}.0 * (0.3 + 0.7 * max(N.y, 0.0)) * uNight;
+    }
+    // Above the reach of every gathered lamp (most of a facade) the loop is skipped.
+    if (P.y > uLampTop) return acc;
+    for (int i = 0; i < ${MAX_LAMPS}; i++) {
+        if (i >= uLampCount) break;
+        vec4 L = uLamps[i];
+        vec3 d = L.xyz - P;
+        float r2 = dot(d, d);
+        float r = sqrt(r2);
+        vec3 l = d / max(r, 1e-3);
+        float x = r / L.w;
+        float win = clamp(1.0 - x * x * x * x, 0.0, 1.0);
+        win *= win;
+        float ndl = max(dot(N, l), 0.0);
+        vec4 A = uLampAims[i];
+        if (A.w > 0.0) {
+            // a projector: an aimed beam (soft edge from the outer cone in), throw nearly flat over its
+            // reach, so a few towers light a whole stadium evenly; walls facing it take light too
+            float spot = smoothstep(A.w, mix(A.w, 1.0, 0.45), dot(-l, A.xyz));
+            acc += uLampColors[i].rgb * (uLampColors[i].a * win * spot * (0.35 + 0.65 * ndl) * 4.0 / (1.0 + x * x * 3.0));
+            continue;
+        }
+        float cone = smoothstep(0.1, 0.7, l.y);
+        float ls = A.w < 0.0 ? -A.w : 1.0;   // the lamp's object scale: falloff over its own metres
+        // Intensity 1 puts ~0.75 irradiance on the ground under an 8 m head, a tenth of that
+        // 14 m along the kerb: street-lamp contrast, not a wash.
+        acc += uLampColors[i].rgb * (uLampColors[i].a * win * ndl * cone * 4.0 / (1.0 + r2 * 0.06 / (ls * ls)));
+    }
+    return acc * uNight;
+}
+
+// Sun + sky + ground + lamps on a rough dielectric. Radiance units: a 0.5 albedo at noon
+// lands near 0.9, so NoToneMapping keeps it under 1.
+vec3 shadeSurface(vec3 albedo, vec3 N, vec3 P, vec3 V, float rough, float ao) {
+    float ndl = max(dot(N, uSunDir), 0.0);
+    vec3 sky = uSkyAmbient * (0.55 + 0.45 * N.y);
+    vec3 gnd = uGroundAmbient * (0.5 - 0.5 * N.y);
+    vec3 col = albedo * (uSunColor * ndl + (sky + gnd) * ao);
+    vec3 H = normalize(uSunDir + V);
+    float spec = pow(max(dot(N, H), 0.0), mix(90.0, 6.0, rough)) * (1.0 - rough) * 0.35 * ndl;
+    col += uSunColor * spec;
+    col += albedo * lampLight(P, N);
+    return col;
+}
+
+// Box-filtered coverage of the band [a, b] over this pixel's footprint on x: exact
+// anti-aliasing at the edge AND the right average when the band is thinner than a pixel
+// (a far facade blends to the mean of glass and spandrel instead of sparkling).
+float bandAA(float x, float a, float b) {
+    float w = max(fwidth(x), 1e-5);
+    float lo = max(a, x - 0.5 * w), hi = min(b, x + 0.5 * w);
+    return clamp((hi - lo) / w, 0.0, 1.0);
+}
+`;
+export const GLSL_FOG_PARS = /* glsl */ `#include <fog_pars_fragment>`;
+export const GLSL_FOG_VERT_PARS = /* glsl */ `#include <fog_pars_vertex>`;
+/** Shared tail: output in the viewer's convention (NoToneMapping, sRGB out, scene fog). */
+export const GLSL_OUT = /* glsl */ `
+    gl_FragColor = vec4(col, 1.0);
+    #include <tonemapping_fragment>
+    #include <colorspace_fragment>
+    #include <fog_fragment>
+`;
+// ---------------------------------------------------------------------------- textures
+const _texCache = new Map();
+/**
+ * maps: { color?, normal?, roughness?, ao? } URLs (a library set's maps). Returns
+ * { color, normal, roughness, ao, mean: THREE.Color, ready: Promise }. Textures repeat;
+ * the colour map is sRGB. `mean` is the colour map's linear mean, filled when it loads.
+ */
+export function loadTextureSet(maps) {
+    const key = JSON.stringify(maps || {});
+    if (_texCache.has(key))
+        return _texCache.get(key);
+    const loader = new THREE.TextureLoader();
+    loader.setCrossOrigin('anonymous');
+    const out = { color: null, normal: null, roughness: null, ao: null, mean: new THREE.Color(0.5, 0.5, 0.5), ready: null };
+    let pending = 4, finish = null;
+    out.ready = new Promise((resolve) => { finish = resolve; });
+    const done = () => { if (--pending === 0 && finish)
+        finish(out); };
+    const prep = (t, srgb) => {
+        t.wrapS = t.wrapT = THREE.RepeatWrapping;
+        t.anisotropy = 8;
+        if (srgb)
+            t.colorSpace = THREE.SRGBColorSpace;
+        return t;
+    };
+    const load = (url, srgb, onLoad) => {
+        if (!url) {
+            done();
+            return;
+        }
+        loader.load(url, (t) => { onLoad(prep(t, srgb)); done(); }, undefined, () => done());
+    };
+    load(maps && maps.color, true, (t) => {
+        out.color = t;
+        const image = t.image;
+        if (image && typeof document !== 'undefined') {
+            // Linear mean of the colour map (16 x 16 downsample), so albedo = knob colour * tex / mean.
+            const c = document.createElement('canvas');
+            c.width = c.height = 16;
+            const g = c.getContext('2d');
+            try {
+                g.drawImage(image, 0, 0, 16, 16);
+                const d = g.getImageData(0, 0, 16, 16).data;
+                let r = 0, gg = 0, b = 0;
+                const lin = (v) => { v /= 255; return v <= 0.04045 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4); };
+                for (let i = 0; i < d.length; i += 4) {
+                    r += lin(d[i]);
+                    gg += lin(d[i + 1]);
+                    b += lin(d[i + 2]);
+                }
+                const n = d.length / 4;
+                out.mean.setRGB(Math.max(r / n, 0.02), Math.max(gg / n, 0.02), Math.max(b / n, 0.02));
+            }
+            catch (e) { /* cross-origin without CORS: keep the neutral mean */ }
+        }
+    });
+    load(maps && maps.normal, false, (t) => { out.normal = t; });
+    load(maps && maps.roughness, false, (t) => { out.roughness = t; });
+    load(maps && maps.ao, false, (t) => { out.ao = t; });
+    _texCache.set(key, out);
+    return out;
+}
+const _white = (() => { const t = new THREE.DataTexture(new Uint8Array([255, 255, 255, 255]), 1, 1); t.needsUpdate = true; return t; })();
+const _flatNormal = (() => { const t = new THREE.DataTexture(new Uint8Array([128, 128, 255, 255]), 1, 1); t.needsUpdate = true; return t; })();
+export function createTextureUniforms(prefix) {
+    const u = {};
+    u[prefix + 'Map'] = { value: _white };
+    u[prefix + 'Normal'] = { value: _flatNormal };
+    u[prefix + 'Rough'] = { value: _white };
+    u[prefix + 'Mean'] = { value: new THREE.Color(1, 1, 1) };
+    u[prefix + 'Tile'] = { value: 2 };
+    u[prefix + 'Has'] = { value: 0 };
+    u[prefix + 'NormalStrength'] = { value: 1 };
+    return u;
+}
+/** Point a texture-uniform block at a loaded set (or clear it when `set` is null). */
+export function applyTextureSet(u, prefix, set, tile = 2, normalStrength = 1) {
+    const has = !!(set && set.color);
+    u[prefix + 'Has'].value = has ? 1 : 0;
+    u[prefix + 'Map'].value = has ? set.color : _white;
+    u[prefix + 'Normal'].value = set && set.normal ? set.normal : _flatNormal;
+    u[prefix + 'Rough'].value = set && set.roughness ? set.roughness : _white;
+    u[prefix + 'Mean'].value.copy(has ? set.mean : new THREE.Color(1, 1, 1));
+    u[prefix + 'Tile'].value = Math.max(0.05, tile || 2);
+    u[prefix + 'NormalStrength'].value = normalStrength;
+}
+/** GLSL for one texture block: sampleTex_<prefix>(uv, N, T, B) -> albedo multiplier, bumped normal, roughness. */
+export function glslTextureBlock(prefix) {
+    return /* glsl */ `
+uniform sampler2D ${prefix}Map;
+uniform sampler2D ${prefix}Normal;
+uniform sampler2D ${prefix}Rough;
+uniform vec3 ${prefix}Mean;
+uniform float ${prefix}Tile;
+uniform float ${prefix}Has;
+uniform float ${prefix}NormalStrength;
+// albedoMul: texture / its mean (1.0 without a texture), so the knob colour stays the average.
+vec3 ${prefix}Sample(vec2 uvM, inout vec3 N, vec3 T, vec3 B, out float rough) {
+    vec2 uv = uvM / ${prefix}Tile;
+    vec3 c = texture2D(${prefix}Map, uv).rgb;
+    vec3 albedoMul = mix(vec3(1.0), min(c / ${prefix}Mean, vec3(4.0)), ${prefix}Has);
+    vec3 nm = texture2D(${prefix}Normal, uv).xyz * 2.0 - 1.0;
+    // Relief fades out as the texture minifies (a bumped normal at sub-texel scale is just speckle).
+    float px = fwidth(uv.x) + fwidth(uv.y);
+    nm.xy *= ${prefix}NormalStrength * ${prefix}Has * (1.0 - smoothstep(0.004, 0.03, px));
+    N = normalize(T * nm.x + B * nm.y + N * max(nm.z, 0.2));
+    rough = mix(0.85, texture2D(${prefix}Rough, uv).r, ${prefix}Has);
+    return albedoMul;
+}`;
+}
+// ---------------------------------------------------------------------------- paths and ribbons
+/** Sample the polyline: [{ p: Vector3, t: Vector3 (tangent), n: Vector3 (right), s }] */
+/**
+ * Sample a polyline ([x, z] metres) into frames every ~1.5 m: [{ p, t (tangent), n (right), s }].
+ * `curve` 0 keeps the corners, 1 rounds the path (Catmull-Rom tension); `closed` loops it.
+ */
+export function samplePath(points, curve = 0.5, closed = false) {
+    const pts = (points || []).filter((p) => Array.isArray(p) && p.length >= 2).map((p) => new THREE.Vector3(p[0], 0, p[1]));
+    if (pts.length < 2)
+        return [];
+    let path;
+    if (pts.length === 2 && !closed)
+        path = new THREE.LineCurve3(pts[0], pts[1]);
+    else
+        path = new THREE.CatmullRomCurve3(pts, closed, 'catmullrom', 0.5 * Math.min(1, Math.max(0, curve)));
+    const len = path.getLength();
+    const n = Math.max(2, Math.ceil(len / 1.5));
+    const spaced = path.getSpacedPoints(n);
+    const out = [];
+    let s = 0;
+    for (let i = 0; i <= n; i++) {
+        const p = spaced[i];
+        if (i > 0)
+            s += p.distanceTo(spaced[i - 1]);
+        const a = closed ? spaced[(i - 1 + n) % n] : spaced[Math.max(0, i - 1)], b = closed ? spaced[(i + 1) % n] : spaced[Math.min(n, i + 1)];
+        const t = new THREE.Vector3().subVectors(b, a);
+        t.y = 0;
+        t.normalize();
+        const nrm = new THREE.Vector3(t.z, 0, -t.x); // right of travel
+        out.push({ p, t, n: nrm, s });
+    }
+    return out;
+}
+// ---------------------------------------------------------------------------- geometry
+/** A ribbon between offsets ta..tb (across) at heights ya..yb along the sampled path; uv = (s, t) or (s, y) for faces. */
+export function ribbon(samples, ta, tb, ya, yb, vertical = false, facing = 1) {
+    // vertical: a wall at t = ta (= tb) from ya to yb; `facing` +1 = normal away from the road (+n side), -1 = toward it.
+    const n = samples.length;
+    const pos = new Float32Array(n * 2 * 3), nor = new Float32Array(n * 2 * 3), st = new Float32Array(n * 2 * 2);
+    const idx = [];
+    const A = new THREE.Vector3(), Bv = new THREE.Vector3(), C = new THREE.Vector3(), fn = new THREE.Vector3(), want = new THREE.Vector3();
+    for (let i = 0; i < n; i++) {
+        const S = samples[i];
+        const ax = S.p.x + S.n.x * ta, az = S.p.z + S.n.z * ta;
+        const bx = S.p.x + S.n.x * tb, bz = S.p.z + S.n.z * tb;
+        pos.set([ax, ya, az, bx, yb, bz], i * 6);
+        if (vertical) {
+            const sgn = (Math.sign(ta) || 1) * facing;
+            nor.set([S.n.x * sgn, 0, S.n.z * sgn, S.n.x * sgn, 0, S.n.z * sgn], i * 6);
+            st.set([S.s, ya, S.s, yb], i * 4);
+        }
+        else {
+            nor.set([0, 1, 0, 0, 1, 0], i * 6);
+            st.set([S.s, ta, S.s, tb], i * 4);
+        }
+        if (i < n - 1) {
+            const a = i * 2;
+            // Wind each quad so its geometric normal agrees with the stored one.
+            idx.push(a, a + 2, a + 1, a + 1, a + 2, a + 3);
+        }
+    }
+    // Fix the winding per strip from the first quad.
+    if (n > 1) {
+        A.fromArray(pos, 0);
+        Bv.fromArray(pos, 6);
+        C.fromArray(pos, 3);
+        fn.subVectors(Bv, A).cross(C.clone().sub(A));
+        want.fromArray(nor, 0);
+        if (fn.dot(want) < 0)
+            for (let k = 0; k < idx.length; k += 3) {
+                const t = idx[k + 1];
+                idx[k + 1] = idx[k + 2];
+                idx[k + 2] = t;
+            }
+    }
+    const g = new THREE.BufferGeometry();
+    g.setAttribute('position', new THREE.BufferAttribute(pos, 3));
+    g.setAttribute('normal', new THREE.BufferAttribute(nor, 3));
+    g.setAttribute('aUV', new THREE.BufferAttribute(st, 2));
+    g.setIndex(idx);
+    return g;
+}
+// ---------------------------------------------------------------------------- geometry merge
+/**
+ * Merge indexed or non-indexed geometries into one (position, normal + the named float/vec
+ * attributes, missing ones filled with `fill[name]` or 0). Disposes the inputs.
+ */
+export function mergeGeometries(list, attrs = [], fill = undefined) {
+    let count = 0;
+    for (const g of list)
+        count += g.getAttribute('position').count;
+    const pos = new Float32Array(count * 3), nor = new Float32Array(count * 3);
+    const extra = {};
+    for (const [name, size] of attrs)
+        extra[name] = new Float32Array(count * size);
+    const idx = [];
+    let o = 0;
+    for (const g of list) {
+        const P = g.getAttribute('position'), N = g.getAttribute('normal');
+        pos.set(P.array, o * 3);
+        nor.set(N.array, o * 3);
+        for (const [name, size] of attrs) {
+            const a = g.getAttribute(name);
+            if (a)
+                extra[name].set(a.array, o * size);
+            else {
+                const f = (fill && fill[name] !== undefined) ? fill[name] : (g.userData[name] !== undefined ? g.userData[name] : 0);
+                for (let i = 0; i < P.count * size; i++)
+                    extra[name][o * size + i] = f;
+            }
+        }
+        if (g.index)
+            for (let i = 0; i < g.index.count; i++)
+                idx.push(g.index.getX(i) + o);
+        else
+            for (let i = 0; i < P.count; i++)
+                idx.push(i + o);
+        o += P.count;
+        g.dispose();
+    }
+    const m = new THREE.BufferGeometry();
+    m.setAttribute('position', new THREE.BufferAttribute(pos, 3));
+    m.setAttribute('normal', new THREE.BufferAttribute(nor, 3));
+    for (const [name, size] of attrs)
+        m.setAttribute(name, new THREE.BufferAttribute(extra[name], size));
+    m.setIndex(idx);
+    m.computeBoundingBox();
+    m.computeBoundingSphere();
+    return m;
+}
+// ---------------------------------------------------------------------------- merge by material
+/**
+ * Merge every mesh under `roots` into as few meshes as there are materials (instanced meshes of
+ * the same geometry into one InstancedMesh), added to `group` in its local space, lit by a baked
+ * lamp `field`. Used by objects built from other variants' cores (a street grid, a block's
+ * streets): ~200 pieces become ~10 draw calls. A merged mesh draws with the FIRST piece's
+ * material — the pieces' knob uniforms all receive the same config, so any one stands for all;
+ * a per-piece difference must be a vertex attribute (the junction's aTee / aRound), never a
+ * uniform. A material can keep itself apart with material.userData.mergeKey (a lawn island).
+ * The originals leave the scene graph; their cores still own and dispose them. Returns the
+ * merged meshes (dispose their geometry; the materials are the pieces').
+ */
+export function mergeByMaterial(group, roots, field) {
+    const inv = new THREE.Matrix4(), im = new THREE.Matrix4(), col = new THREE.Color();
+    group.updateMatrixWorld(true);
+    inv.copy(group.matrixWorld).invert();
+    const sets = new Map();
+    for (const root of roots) {
+        const meshes = [];
+        root.traverse((o) => { if (o.isMesh)
+            meshes.push(o); });
+        for (const m of meshes) {
+            const mat = m.material, g = m.geometry;
+            let sig = '';
+            if (m.isInstancedMesh) {
+                if (!g.boundingBox)
+                    g.computeBoundingBox();
+                sig = g.getAttribute('position').count + ':' + g.boundingBox.max.y.toFixed(3) + ':' + !!m.instanceColor;
+            }
+            const key = (m.isInstancedMesh ? 'I' : 'M') + '|' + mat.vertexShader + '|' + mat.fragmentShader + '|' + Object.keys(g.attributes).sort().join(',')
+                + '|' + mat.polygonOffsetFactor + ',' + mat.polygonOffsetUnits + '|' + m.renderOrder + '|' + sig + '|' + (mat.userData.mergeKey || '');
+            let set = sets.get(key);
+            if (!set)
+                sets.set(key, (set = { first: m, list: [] }));
+            set.list.push({ mesh: m, rel: new THREE.Matrix4().multiplyMatrices(inv, m.matrixWorld) });
+        }
+    }
+    const merged = [];
+    for (const set of sets.values()) {
+        const first = set.first;
+        let mesh;
+        if (first.isInstancedMesh) {
+            let n = 0;
+            for (const e of set.list)
+                n += e.mesh.count;
+            mesh = new THREE.InstancedMesh(first.geometry.clone(), first.material, n);
+            let o = 0;
+            for (const e of set.list)
+                for (let i = 0; i < e.mesh.count; i++, o++) {
+                    e.mesh.getMatrixAt(i, im);
+                    im.premultiply(e.rel);
+                    mesh.setMatrixAt(o, im);
+                    if (e.mesh.instanceColor) {
+                        e.mesh.getColorAt(i, col);
+                        mesh.setColorAt(o, col);
+                    }
+                }
+            mesh.instanceMatrix.needsUpdate = true;
+            if (mesh.instanceColor)
+                mesh.instanceColor.needsUpdate = true;
+        }
+        else {
+            const geos = set.list.map((e) => e.mesh.geometry.clone().applyMatrix4(e.rel));
+            const extra = Object.keys(geos[0].attributes).filter((a) => a !== 'position' && a !== 'normal').map((a) => [a, geos[0].getAttribute(a).itemSize]);
+            mesh = new THREE.Mesh(mergeGeometries(geos, extra), first.material);
+        }
+        mesh.frustumCulled = false;
+        mesh.renderOrder = first.renderOrder;
+        mesh.castShadow = first.castShadow;
+        mesh.receiveShadow = first.receiveShadow;
+        if (field)
+            attachLampField(first.material.uniforms, field);
+        group.add(mesh);
+        merged.push(mesh);
+    }
+    for (const set of sets.values())
+        for (const e of set.list)
+            if (e.mesh.parent)
+                e.mesh.parent.remove(e.mesh);
+    return merged;
+}
+// ---------------------------------------------------------------------------- lamp fixture geometry
+/**
+ * A street lamp as one BufferGeometry: tapered pole, a curved arm, a flat head whose
+ * underside is the emissive panel. Attributes: position, normal, aEmissive (1 on the panel).
+ * Base at the origin, head at (armReach, height, 0) facing -y. Pure function of its params.
+ */
+export function buildLampGeometry(p) {
+    const height = p.height || 7, reach = p.armReach === undefined ? 1.6 : p.armReach;
+    const headW = p.headWidth || 0.9, headD = p.headDepth || 0.35, headH = 0.16;
+    const parts = [];
+    const pole = new THREE.CylinderGeometry(0.06, 0.11, height, 10, 1);
+    pole.translate(0, height / 2, 0);
+    parts.push(pole);
+    // Arm: a quarter-circle sweep from the pole top out to the head, 6 tube segments.
+    const curve = new THREE.CubicBezierCurve3(new THREE.Vector3(0, height, 0), new THREE.Vector3(0, height + 0.5, 0), new THREE.Vector3(reach * 0.5, height + 0.55, 0), new THREE.Vector3(reach, height + 0.4, 0));
+    const arm = new THREE.TubeGeometry(curve, 6, 0.045, 8, false);
+    parts.push(arm);
+    const head = new THREE.BoxGeometry(headW, headH, headD);
+    head.translate(reach, height + 0.35, 0);
+    parts.push(head);
+    // Merge by hand (keeps the lab free of BufferGeometryUtils).
+    let count = 0;
+    for (const g of parts)
+        count += g.getAttribute('position').count;
+    const pos = new Float32Array(count * 3), nor = new Float32Array(count * 3), emi = new Float32Array(count);
+    const idx = [];
+    let o = 0;
+    for (const g of parts) {
+        const ng = g.index ? g : g;
+        const P = ng.getAttribute('position'), N = ng.getAttribute('normal');
+        for (let i = 0; i < P.count; i++) {
+            pos[(o + i) * 3] = P.getX(i);
+            pos[(o + i) * 3 + 1] = P.getY(i);
+            pos[(o + i) * 3 + 2] = P.getZ(i);
+            nor[(o + i) * 3] = N.getX(i);
+            nor[(o + i) * 3 + 1] = N.getY(i);
+            nor[(o + i) * 3 + 2] = N.getZ(i);
+            // The head's underside (normal -y) is the lit panel.
+            emi[o + i] = (g === head && N.getY(i) < -0.5) ? 1 : 0;
+        }
+        if (ng.index)
+            for (let i = 0; i < ng.index.count; i++)
+                idx.push(ng.index.getX(i) + o);
+        else
+            for (let i = 0; i < P.count; i++)
+                idx.push(i + o);
+        o += P.count;
+        g.dispose();
+    }
+    const geo = new THREE.BufferGeometry();
+    geo.setAttribute('position', new THREE.BufferAttribute(pos, 3));
+    geo.setAttribute('normal', new THREE.BufferAttribute(nor, 3));
+    geo.setAttribute('aEmissive', new THREE.BufferAttribute(emi, 1));
+    geo.setAttribute('aAccent', new THREE.BufferAttribute(new Float32Array(count), 1));
+    geo.setIndex(idx);
+    geo.userData.head = new THREE.Vector3(reach, height + 0.27, 0);
+    return geo;
+}
+// ---------------------------------------------------------------------------- paving material
+// A textured hard surface lit by the shared sun block and the lamp list: sidewalks, kerbs,
+// a block's plot, a plaza. Geometry carries aUV in METRES (so one tile size means the same
+// everywhere); the normal picks the tangent frame.
+export function createPavingUniforms() {
+    return Object.assign(createSunUniforms(), createLampUniforms(), createTextureUniforms('uPav'), {
+        uPavColor: { value: new THREE.Color('#9b9792') },
+        uPavRoughness: { value: 0.9 },
+        uGrassMix: { value: 0 }, // 1 = lawn look (no texture, noise-broken green)
+    });
+}
+export const PAVING_VERT = /* glsl */ `
+attribute vec2 aUV;
+varying vec3 vN; varying vec3 vP; varying vec2 vUVm; varying vec3 vLocalN;
+${GLSL_FOG_VERT_PARS}
+void main() {
+    #ifdef USE_INSTANCING
+    mat4 m = modelMatrix * instanceMatrix;
+    #else
+    mat4 m = modelMatrix;
+    #endif
+    vec4 wp = m * vec4(position, 1.0);
+    vP = wp.xyz;
+    vN = normalize(mat3(m) * normal);
+    vLocalN = normal;
+    vUVm = aUV;
+    vec4 mvPosition = viewMatrix * wp;
+    gl_Position = projectionMatrix * mvPosition;
+    #include <fog_vertex>
+}`;
+export const PAVING_FRAG = /* glsl */ `
+precision highp float;
+${GLSL_COMMON}
+${glslTextureBlock('uPav')}
+uniform vec3 uPavColor; uniform float uPavRoughness; uniform float uGrassMix;
+varying vec3 vN; varying vec3 vP; varying vec2 vUVm; varying vec3 vLocalN;
+${GLSL_FOG_PARS}
+void main() {
+    vec3 N = normalize(vN);
+    vec3 V = normalize(cameraPosition - vP);
+    vec3 T = abs(vLocalN.y) > 0.9 ? vec3(1.0, 0.0, 0.0) : normalize(cross(vec3(0.0, 1.0, 0.0), N));
+    vec3 B = abs(vLocalN.y) > 0.9 ? vec3(0.0, 0.0, 1.0) : vec3(0.0, 1.0, 0.0);
+    float rough;
+    vec3 Nb = N;
+    vec3 mul = uPavSample(vUVm, Nb, T, B, rough);
+    rough = mix(rough, uPavRoughness, 0.5);
+    // Large-scale tone variation so a long sidewalk is not one repeated tile.
+    float macro = 1.0 + (0.2 * vnoise21(vUVm / 9.0) - 0.1) * uPavHas;
+    vec3 albedo = uPavColor * mul * macro;
+    // Lawn: no texture, two greens broken by a cell hash and a soft gradient.
+    // Lawn: two greens broken by cells and a soft gradient, tinted by the colour knob (neutral at #4f7a2e).
+    vec3 lawn = mix(vec3(0.16, 0.30, 0.09), vec3(0.28, 0.42, 0.14), hash21(floor(vUVm * 1.7)) * 0.6 + 0.2 * sin(vUVm.x * 0.7) * cos(vUVm.y * 0.5)) * (uPavColor / vec3(0.31, 0.48, 0.18));
+    albedo = mix(albedo, lawn, uGrassMix);
+    vec3 col = shadeSurface(albedo, Nb, vP, V, mix(rough, 0.95, uGrassMix), 1.0);
+${GLSL_OUT}
+}`;
+/**
+ * Depth options for the family's flat ground surfaces (asphalt, paving, plaza slabs). They sit
+ * centimetres above the scene's terrain or a ground plane; without an offset the depth buffer
+ * cannot tell them apart at distance and they flicker as the camera moves (z-fighting).
+ * A polygon offset pulls them toward the camera in depth only — nothing moves on screen.
+ */
+export const SURFACE_DEPTH = { polygonOffset: true, polygonOffsetFactor: -2, polygonOffsetUnits: -4 };
+export function createPavingMaterial(u) {
+    return new THREE.ShaderMaterial({ uniforms: Object.assign(THREE.UniformsUtils.clone(THREE.UniformsLib.fog), u), vertexShader: PAVING_VERT, fragmentShader: PAVING_FRAG, fog: true, ...SURFACE_DEPTH });
+}
+// ---------------------------------------------------------------------------- fixture material
+// Painted metal lit by the shared sun block, with the emissive head panel: lit at night (uNight),
+// a glowing disc brighter than 1 so bloom (render task) can pick it up. One material for every
+// fixture of an object; instanced or not.
+export function createFixtureUniforms() {
+    return Object.assign(createSunUniforms(), createLampUniforms(), {
+        uPaint: { value: new THREE.Color('#2b2f33') },
+        uAccent: { value: new THREE.Color('#8a5a2b') },
+        uLampColor: { value: new THREE.Color('#ffd9a0') },
+        uLampGlow: { value: 1 },
+        uRough: { value: 0.55 },
+    });
+}
+export const FIXTURE_VERT = /* glsl */ `
+attribute float aEmissive;
+attribute float aAccent;
+varying vec3 vN; varying vec3 vP; varying float vE; varying float vA; varying vec3 vIC;
+${GLSL_FOG_VERT_PARS}
+void main() {
+    vec3 n = normal;
+    #ifdef USE_INSTANCING
+    mat4 m = modelMatrix * instanceMatrix;
+    #else
+    mat4 m = modelMatrix;
+    #endif
+    // Per-instance paint (InstancedMesh.instanceColor): cars in a parking lot, else white.
+    vIC = vec3(1.0);
+    #ifdef USE_INSTANCING_COLOR
+    vIC = instanceColor;
+    #endif
+    vec4 wp = m * vec4(position, 1.0);
+    vP = wp.xyz;
+    vN = normalize(mat3(m) * n);
+    vE = aEmissive;
+    vA = aAccent;
+    vec4 mvPosition = viewMatrix * wp;
+    gl_Position = projectionMatrix * mvPosition;
+    #include <fog_vertex>
+}`;
+export const FIXTURE_FRAG = /* glsl */ `
+precision highp float;
+${GLSL_COMMON}
+uniform vec3 uPaint; uniform vec3 uAccent; uniform vec3 uLampColor; uniform float uLampGlow; uniform float uRough;
+varying vec3 vN; varying vec3 vP; varying float vE; varying float vA; varying vec3 vIC;
+${GLSL_FOG_PARS}
+void main() {
+    vec3 N = normalize(vN);
+    vec3 V = normalize(cameraPosition - vP);
+    vec3 base = mix(uPaint * vIC, uAccent, vA);
+    vec3 col = shadeSurface(base, N, vP, V, mix(uRough, 0.8, vA), 1.0);
+    // The panel: dim diffuser by day, a bright warm disc at night (over 1.0 on purpose, for bloom).
+    vec3 panel = mix(uPaint * 1.6, uLampColor * (1.0 + 2.2 * uLampGlow), uNight);
+    col = mix(col, panel, vE);
+    float alpha = 1.0;
+    #ifdef GLASS
+    // Shelter glass: a faint tint plus a Fresnel sky reflection, mostly see-through.
+    float fres = 0.04 + 0.96 * pow(1.0 - abs(dot(N, V)), 5.0);
+    col = uAccent * 0.08 * (uSkyAmbient + uSunColor * 0.3) + (uSkyAmbient * 2.0 + uSunColor * 0.1) * fres * 0.8;
+    alpha = 0.18 + 0.7 * fres;
+    #endif
+    gl_FragColor = vec4(col, alpha);
+    #include <tonemapping_fragment>
+    #include <colorspace_fragment>
+    #include <fog_fragment>
+}`;
+// ---------------------------------------------------------------------------- low-poly car
+// The family's crowd car (parked in a parkingLot, driving in traffic): one geometry, ~80 triangles,
+// in the fixture material with per-car paint from CAR_PALETTE. A car MODEL from the library is still
+// the better hero car; these are the crowd.
+export const CAR_PALETTE = ['#e8e8e8', '#cfd2d6', '#1d1f22', '#6c7076', '#9b1b1b', '#1f3f7a', '#2f4f3a', '#b9b1a0', '#4a4a4a', '#e3e3e3'];
+/** A low-poly car as one geometry, facing +x, base at y = 0: body, cabin (accent = dark glass), four wheels (accent). */
+export function buildCarGeometry() {
+    const parts = [];
+    const box = (w, h, d, x, y, z, accent) => { const g = new THREE.BoxGeometry(w, h, d); g.translate(x, y, z); g.userData.aAccent = accent; g.userData.aEmissive = 0; parts.push(g); };
+    box(4.4, 0.55, 1.8, 0, 0.55, 0, 0); // lower body
+    box(4.0, 0.35, 1.7, -0.1, 0.98, 0, 0); // upper body
+    box(2.3, 0.6, 1.62, -0.25, 1.42, 0, 1); // cabin (dark)
+    for (const sx of [-1, 1])
+        for (const sz of [-1, 1])
+            box(0.64, 0.64, 0.3, sx * 1.4, 0.32, sz * 0.82, 1);
+    return mergeGeometries(parts, [['aEmissive', 1], ['aAccent', 1]]);
+}
+export function createFixtureMaterial(u, glass = false) {
+    return new THREE.ShaderMaterial({ uniforms: Object.assign(THREE.UniformsUtils.clone(THREE.UniformsLib.fog), u), vertexShader: FIXTURE_VERT, fragmentShader: FIXTURE_FRAG, fog: true,
+        defines: glass ? { GLASS: 1 } : {}, transparent: !!glass, depthWrite: !glass, side: glass ? THREE.DoubleSide : THREE.FrontSide });
+}