@3driseai/3drise-viewer 0.1.42 → 0.1.43

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

@@ -0,0 +1,617 @@
+// Emitted from Claude outputs/urban-lab/junction.mjs by emit_object.mjs — edit the lab module and re-emit.
+// =============================================================================
+// urban/junction — a road intersection: cross or T, rounded kerbs, crossings, signals
+// =============================================================================
+// Construction. The asphalt is ONE flat polygon: the central square (W x W, W = lanes x lane
+// width) with an arm stub on each side (armLength) and the corners between arms cut in a
+// quarter circle (cornerRadius), triangulated with UVs in metres. The corner pavements are
+// the complementary shapes (square minus the quarter disc) with a kerb ribbon along their
+// inner edge. Markings are per fragment in metres: on each arm the lane dashes, edge
+// lines, a stop line at the box edge and a zebra behind it; the box itself stays plain.
+// Roads butt against the arm ends (same lanes / lane width), so a crossing is a junction
+// plus roads ending at its arms — the two never overlap.
+//
+// Signals. One pole per corner carries a three-light head facing the approaching arm. All
+// heads are one merged geometry with one shader: each light knows its colour (red / amber /
+// green) and its axis group (x arms or z arms); a phase uniform cycles the groups through
+// green - amber - red with an all-red gap. Emissive only (no light); off by day unless the
+// object is forced to night.
+import * as THREE from 'three';
+import { createSunUniforms, createLampUniforms, createTextureUniforms, applyTextureSet, glslTextureBlock, GLSL_COMMON, GLSL_FOG_PARS, GLSL_FOG_VERT_PARS, GLSL_OUT, loadTextureSet, createPavingUniforms, createPavingMaterial, ribbon, mergeGeometries, SURFACE_DEPTH, buildLampGeometry, createFixtureUniforms, createFixtureMaterial, registerLamp, unregisterLamp, touchLamps, setLamps, placeLamps, } from '../urbanCore.js';
+import { slabGeometry } from './plaza.js';
+export const SHAPES = ['cross', 'tee', 'roundabout', 'roundabout3']; // roundabout3: three arms, no -z arm (like a T)
+const isRound = (shape) => shape === 'roundabout' || shape === 'roundabout3';
+export const LIGHTING = ['auto', 'day', 'night'];
+export const STRUCTURAL = ['shape', 'islandRadius', 'lanes', 'laneWidth', 'armLength', 'cornerRadius', 'texture', 'sidewalk', 'kerbHeight', 'sidewalkTexture', 'signals', 'signalHeight', 'lamps', 'lampHeight', 'seed'];
+// ---------------------------------------------------------------------------- asphalt material
+export function createUniforms() {
+    return Object.assign(createSunUniforms(), createLampUniforms(), createTextureUniforms('uAsp'), {
+        uAsphaltColor: { value: new THREE.Color() },
+        uMarkingColor: { value: new THREE.Color() },
+        uWidth: { value: 7 },
+        uLaneWidth: { value: 3.5 },
+        uLanes: { value: 2 },
+        uArm: { value: 14 },
+        uCrosswalks: { value: 1 },
+        uWear: { value: 0.5 },
+        uSeed: { value: 0 },
+    });
+}
+export function applyConfig(u, c, tex = undefined) {
+    if (c.asphaltColor !== undefined)
+        u.uAsphaltColor.value.set(c.asphaltColor);
+    if (c.markingColor !== undefined)
+        u.uMarkingColor.value.set(c.markingColor);
+    if (c.crosswalks !== undefined)
+        u.uCrosswalks.value = c.crosswalks ? 1 : 0;
+    if (c.wear !== undefined)
+        u.uWear.value = c.wear;
+    if (c.lanes !== undefined && c.laneWidth !== undefined) {
+        u.uLanes.value = Math.max(1, Math.round(c.lanes));
+        u.uLaneWidth.value = c.laneWidth;
+        u.uWidth.value = Math.max(1, Math.round(c.lanes)) * c.laneWidth;
+    }
+    if (c.armLength !== undefined)
+        u.uArm.value = c.armLength;
+    if (c.seed !== undefined)
+        u.uSeed.value = c.seed;
+    if (tex !== undefined)
+        applyTextureSet(u, 'uAsp', tex, c.texture && c.texture.tileSize, 0.6);
+}
+export const VERT = /* glsl */ `
+attribute vec2 aUV;
+attribute float aTee;         // 1 on a T (no -z arm): per vertex, so a street grid can merge tees and crosses
+attribute float aRound;       // a roundabout's island radius (0 = a crossing), per vertex for the same reason
+varying vec3 vN; varying vec3 vP; varying vec2 vQ; varying float vTee; varying float vRound;
+${GLSL_FOG_VERT_PARS}
+void main() {
+    vec4 wp = modelMatrix * vec4(position, 1.0);
+    vP = wp.xyz;
+    vN = normalize(mat3(modelMatrix) * normal);
+    vQ = aUV;
+    vTee = aTee; vRound = aRound;
+    vec4 mvPosition = viewMatrix * wp;
+    gl_Position = projectionMatrix * mvPosition;
+    #include <fog_vertex>
+}`;
+export const FRAG = /* glsl */ `
+precision highp float;
+${GLSL_COMMON}
+${glslTextureBlock('uAsp')}
+uniform vec3 uAsphaltColor; uniform vec3 uMarkingColor;
+uniform float uWidth; uniform float uLaneWidth; uniform float uLanes; uniform float uArm; uniform float uCrosswalks; uniform float uWear; uniform float uSeed;
+varying vec3 vN; varying vec3 vP; varying vec2 vQ; varying float vTee; varying float vRound;
+${GLSL_FOG_PARS}
+
+float lineAA(float x, float w) { return 1.0 - bandAA(abs(x), w * 0.5, 1e9); }
+float dashAA(float s) { float m = mod(s, 12.0); return bandAA(m, 0.0, 3.0); }
+
+// Markings of one arm, in the arm's own frame: a = metres out from the box edge, t = across (metres from the arm centre).
+// ys = 0: a crossing (a stop line across the arm); ys = +-1: a roundabout entry — a dashed give-way
+// line across the entry half only (the half where t * ys > 0).
+float armMarks(float a, float t, float ys) {
+    float lw = 0.12, hw = uWidth * 0.5;
+    float m = 0.0;
+    // Lane boundaries (dashed) and the centre line (dashed), edge lines solid, only past the zebra.
+    float past = bandAA(a, 5.8, 1e9);
+    float bPos = mod(t + hw + uLaneWidth * 0.5, uLaneWidth) - uLaneWidth * 0.5;
+    float even = 1.0 - mod(uLanes, 2.0);
+    float notEdge = 1.0 - step(hw - uLaneWidth * 0.25, abs(t));
+    m += lineAA(bPos, lw) * dashAA(a + 6.0) * notEdge * past;
+    m += lineAA(t, lw) * even * dashAA(a) * past;
+    m += lineAA(abs(t) - (hw - 0.3), lw);
+    // Zebra 2..5 m out, stop line at 5.4..5.75.
+    float zebra = bandAA(a, 2.0, 5.0) * bandAA(mod(t + hw, 1.0), 0.0, 0.5) * uCrosswalks;
+    if (ys == 0.0) zebra = max(zebra, bandAA(a, 5.4, 5.75) * uCrosswalks);
+    else zebra = max(zebra, bandAA(a, 0.4, 0.75) * bandAA(mod(t, 1.0), 0.0, 0.55) * step(0.0, t * ys));
+    return clamp(max(m, zebra), 0.0, 1.0);
+}
+
+// A roundabout's ring (local frame, island radius ri): edge lines, dashed lane lines around it, no
+// edge line across the arm mouths.
+float ringMarks(vec2 q, float ri) {
+    float lw = 0.12, hw = uWidth * 0.5;
+    float r = length(q), ro = ri + uWidth, inner = r - ri;
+    float ph = atan(q.y, q.x) * r;
+    float m = lineAA(r - (ri + 0.3), lw);
+    float laneLine = lineAA(mod(inner + uLaneWidth * 0.5, uLaneWidth) - uLaneWidth * 0.5, lw);
+    m += laneLine * dashAA(ph) * step(uLaneWidth * 0.5, inner) * step(inner, uWidth - uLaneWidth * 0.5);
+    float mouth = max(step(abs(q.y), hw), step(abs(q.x), hw) * max(step(0.0, q.y), 1.0 - step(0.5, vTee)));
+    m += lineAA(r - (ro - 0.3), lw) * (1.0 - mouth);
+    return clamp(m, 0.0, 1.0);
+}
+
+void main() {
+    vec3 N = normalize(vN);
+    vec3 V = normalize(cameraPosition - vP);
+    vec3 T = vec3(1.0, 0.0, 0.0), B = vec3(0.0, 0.0, 1.0);
+    float rough;
+    vec3 Nb = N;
+    vec3 mul = uAspSample(vQ, Nb, T, B, rough);
+    float hw = uWidth * 0.5;
+    float x = vQ.x, z = vQ.y;
+    // Which arm (if any) this fragment is on: outside the central box along one axis.
+    float mark = 0.0, tracks = 0.0;
+    if (vRound > 0.5) {
+        // A roundabout: the ring, then the arms from the ring's outer edge (give-way on the entry half;
+        // right-hand traffic: entering the +x arm you drive toward -x on its -z half).
+        float ro = vRound + uWidth;
+        if (length(vQ) < ro + 0.01) mark = ringMarks(vQ, vRound);
+        else if (abs(z) <= hw) mark = armMarks(abs(x) - ro, z, -sign(x));
+        else if (abs(x) <= hw && !(vTee > 0.5 && z < 0.0)) mark = armMarks(abs(z) - ro, x, sign(z));
+    } else {
+        if (abs(x) > hw && abs(z) <= hw) mark = armMarks(abs(x) - hw, z, 0.0);            // +x / -x arms
+        else if (abs(z) > hw && abs(x) <= hw) {
+            if (!(vTee > 0.5 && z < 0.0)) mark = armMarks(abs(z) - hw, x, 0.0);               // +z / -z arms (a T has no -z arm)
+        }
+        // Wheel wear through the box along both axes.
+        float lanePosX = mod(z + hw, uLaneWidth) - uLaneWidth * 0.5;
+        float lanePosZ = mod(x + hw, uLaneWidth) - uLaneWidth * 0.5;
+        tracks = max(exp(-pow((abs(lanePosX) - 0.9) / 0.45, 2.0)) * step(abs(z), hw), exp(-pow((abs(lanePosZ) - 0.9) / 0.45, 2.0)) * step(abs(x), hw));
+    }
+    float macro = 0.92 + 0.16 * vnoise21(vQ / 9.0 + uSeed);
+    vec3 albedo = uAsphaltColor * mul * macro * (1.0 - 0.18 * uWear * tracks);
+    rough = mix(rough, 0.95, 0.4);
+    float chip = hash21(floor(vec2(x * 2.0, z * 4.0)) + uSeed);
+    mark *= 1.0 - clamp(uWear * (0.35 * step(chip, 0.25 * uWear) + 0.4 * tracks), 0.0, 0.85);
+    albedo = mix(albedo, uMarkingColor * mix(1.0, 0.75, chip * uWear), mark);
+    rough = mix(rough, 0.6, mark);
+    vec3 col = shadeSurface(albedo, Nb, vP, V, rough, 1.0);
+${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, ...SURFACE_DEPTH });
+}
+// ---------------------------------------------------------------------------- signals material
+export function createSignalUniforms() {
+    return Object.assign(createSunUniforms(), createLampUniforms(), {
+        uPaint: { value: new THREE.Color('#2b2f33') },
+        uPhase: { value: 0 }, // 0..1 through one cycle
+        uOn: { value: 1 }, // night factor gate (signals also show by day, dimmer)
+    });
+}
+const SIGNAL_VERT = /* glsl */ `
+attribute float aLight;   // 0 red, 1 amber, 2 green, -1 body
+attribute float aGroup;   // 0 x arms, 1 z arms
+varying vec3 vN; varying vec3 vP; varying float vL; varying float vG;
+${GLSL_FOG_VERT_PARS}
+void main() {
+    vec4 wp = modelMatrix * vec4(position, 1.0);
+    vP = wp.xyz; vN = normalize(mat3(modelMatrix) * normal); vL = aLight; vG = aGroup;
+    vec4 mvPosition = viewMatrix * wp;
+    gl_Position = projectionMatrix * mvPosition;
+    #include <fog_vertex>
+}`;
+const SIGNAL_FRAG = /* glsl */ `
+precision highp float;
+${GLSL_COMMON}
+uniform vec3 uPaint; uniform float uPhase; uniform float uOn;
+varying vec3 vN; varying vec3 vP; varying float vL; varying float vG;
+${GLSL_FOG_PARS}
+// One cycle: x arms green 0..0.40, amber 0.40..0.47, all red 0.47..0.50, z arms green 0.50..0.90, amber 0.90..0.97, all red 0.97..1.
+float lit(float light, float group) {
+    float p = mod(uPhase + group * 0.5, 1.0);     // the z group runs half a cycle behind
+    float green = step(p, 0.40), amber = step(0.40, p) * step(p, 0.47), red = step(0.47, p);
+    return light < 0.5 ? red : light < 1.5 ? amber : green;
+}
+void main() {
+    vec3 N = normalize(vN);
+    vec3 V = normalize(cameraPosition - vP);
+    vec3 col = shadeSurface(uPaint, N, vP, V, 0.5, 1.0);
+    if (vL > -0.5) {
+        vec3 c = vL < 0.5 ? vec3(1.0, 0.1, 0.05) : vL < 1.5 ? vec3(1.0, 0.6, 0.08) : vec3(0.1, 1.0, 0.35);
+        float on = lit(vL, vG);
+        // A lit lens is bright (over 1 for bloom at night); an unlit one is a dark coloured glass.
+        col = mix(c * 0.08 + col * 0.3, c * (1.2 + 1.6 * uNight), on);
+    }
+${GLSL_OUT}
+}`;
+export function createSignalMaterial(u) {
+    return new THREE.ShaderMaterial({ uniforms: Object.assign(THREE.UniformsUtils.clone(THREE.UniformsLib.fog), u), vertexShader: SIGNAL_VERT, fragmentShader: SIGNAL_FRAG, fog: true });
+}
+/** A signal pole: post, a short arm toward the road and a 3-light head facing `facing` (unit xz). Lights tagged by group. */
+function signalGeometry(x, z, facing, group, height) {
+    const parts = [];
+    const tag = (g, light) => { const n = g.getAttribute('position').count; g.setAttribute('aLight', new THREE.BufferAttribute(new Float32Array(n).fill(light), 1)); g.setAttribute('aGroup', new THREE.BufferAttribute(new Float32Array(n).fill(group), 1)); return g; };
+    const ang = Math.atan2(facing.x, facing.z); // rotation about y so +z faces `facing`
+    const place = (g) => { g.rotateY(ang); g.translate(x, 0, z); return g; };
+    parts.push(tag(place(new THREE.CylinderGeometry(0.06, 0.09, height, 10).translate(0, height / 2, 0)), -1));
+    // Head: a box 0.35 x 1.0 x 0.3 at the top, lenses on its +z face.
+    parts.push(tag(place(new THREE.BoxGeometry(0.36, 1.05, 0.3).translate(0, height - 0.5, 0.15)), -1));
+    // Hoods: small plates above each lens.
+    for (let i = 0; i < 3; i++) {
+        const y = height - 0.18 - i * 0.32;
+        parts.push(tag(place(new THREE.BoxGeometry(0.3, 0.03, 0.14).translate(0, y + 0.13, 0.36)), -1));
+        parts.push(tag(place(new THREE.CylinderGeometry(0.1, 0.1, 0.04, 16).rotateX(Math.PI / 2).translate(0, y, 0.31)), i));
+    }
+    return parts;
+}
+// ---------------------------------------------------------------------------- geometry
+/** Outline of the asphalt (cross or T) with concave rounded corners, CCW seen from above. */
+function asphaltOutline(half, arm, R, tee) {
+    const pts = [];
+    const L = half + arm;
+    const arc = (cx, cz, a0, a1) => { const n = 8; for (let i = 0; i <= n; i++) {
+        const a = a0 + (a1 - a0) * i / n;
+        pts.push([cx + Math.cos(a) * R, cz + Math.sin(a) * R]);
+    } };
+    R = Math.min(R, arm - 0.5);
+    // Walk the outline: +x arm end, corner (+x,+z), +z arm, corner (-x,+z), -x arm, corner (-x,-z), -z arm (or straight edge for a T), corner (+x,-z).
+    pts.push([L, -half], [L, half]);
+    arc(half + R, half + R, -Math.PI / 2, -Math.PI); // concave corner between +x and +z arms
+    pts.push([half, L], [-half, L]);
+    arc(-half - R, half + R, 0, -Math.PI / 2);
+    pts.push([-L, half], [-L, -half]);
+    if (tee) {
+        pts.push([-half, -half], [half, -half]); // straight south edge
+    }
+    else {
+        arc(-half - R, -half - R, Math.PI / 2, 0);
+        pts.push([-half, -L], [half, -L]);
+        arc(half + R, -half - R, Math.PI, Math.PI / 2);
+    }
+    return pts;
+}
+/** One corner pavement: the square between two arms minus the quarter disc, plus its kerb path (inner edge). */
+function cornerShape(sx, sz, half, arm, R) {
+    R = Math.min(R, arm - 0.5);
+    const L = half + arm;
+    const pts = [];
+    // From the +x arm edge along the arc to the +z arm edge, then the outer square corner. (sx, sz = ±1 mirror.)
+    const arcPts = [];
+    const n = 10;
+    for (let i = 0; i <= n; i++) {
+        const a = -Math.PI / 2 - (Math.PI / 2) * i / n;
+        arcPts.push([half + R + Math.cos(a) * R, half + R + Math.sin(a) * R]);
+    }
+    pts.push([L, half], ...arcPts.slice(1, n), [half, L], [L, L]);
+    const m = pts.map(([x, z]) => [x * sx, z * sz]);
+    const kerb = [[L, half], ...arcPts, [half, L]].map(([x, z]) => [x * sx, z * sz]);
+    return { outline: m, kerb };
+}
+/**
+ * How far from its centre a junction reaches along each arm: where a road of the same lanes
+ * starts. A crossing: half the road plus the arm; a roundabout: island, ring and the arm.
+ */
+export function junctionReach(c) {
+    const W = Math.max(1, Math.round(c.lanes)) * c.laneWidth;
+    if (isRound(c.shape))
+        return Math.max(2, c.islandRadius) + W + Math.max(c.armLength, 6);
+    return W / 2 + Math.max(c.armLength, 6);
+}
+/** A flat slab from an outline and hole outlines ([[x, z], …]) at height y; aUV = (x, z) metres, facing up. */
+function slabWithHoles(outer, holes, y) {
+    const shape = new THREE.Shape(outer.map(([x, z]) => new THREE.Vector2(x, z)));
+    for (const h of holes)
+        shape.holes.push(new THREE.Path(h.map(([x, z]) => new THREE.Vector2(x, z))));
+    const g = new THREE.ShapeGeometry(shape, 1);
+    const pos = g.getAttribute('position');
+    const uv = new Float32Array(pos.count * 2);
+    for (let i = 0; i < pos.count; i++) {
+        const x = pos.getX(i), z = pos.getY(i);
+        pos.setXYZ(i, x, y, z);
+        uv[i * 2] = x;
+        uv[i * 2 + 1] = z;
+    }
+    pos.needsUpdate = true;
+    g.setAttribute('aUV', new THREE.BufferAttribute(uv, 2));
+    g.computeVertexNormals();
+    if (g.getAttribute('normal').getY(0) < 0) {
+        const idx = g.index;
+        for (let i = 0; i < idx.count; i += 3) {
+            const t = idx.getX(i + 1);
+            idx.setX(i + 1, idx.getX(i + 2));
+            idx.setX(i + 2, t);
+        }
+        idx.needsUpdate = true;
+        g.computeVertexNormals();
+    }
+    g.computeBoundingBox();
+    g.computeBoundingSphere();
+    return g;
+}
+/** A vertical kerb face along a polyline from y0 to y1, its normal turned away from (outward) or toward the centre. */
+function kerbFace(pts, y0, y1, outward) {
+    const ks = pts.map(([x, z], i) => {
+        const q = pts[Math.min(i + 1, pts.length - 1)], p0 = pts[Math.max(i - 1, 0)];
+        const t = new THREE.Vector3(q[0] - p0[0], 0, q[1] - p0[1]).normalize();
+        return { p: new THREE.Vector3(x, 0, z), t, n: new THREE.Vector3(t.z, 0, -t.x), s: i * 1.5 };
+    });
+    const face = ribbon(ks, 0, 0, y1, y0, true, 1);
+    const nrm = face.getAttribute('normal'), p = face.getAttribute('position');
+    const k = Math.floor(nrm.count / 2);
+    const away = nrm.getX(k) * p.getX(k) + nrm.getZ(k) * p.getZ(k) > 0;
+    if (away !== outward) {
+        for (let i = 0; i < nrm.count; i++)
+            nrm.setXYZ(i, -nrm.getX(i), 0, -nrm.getZ(i));
+        const idx = face.index;
+        for (let i = 0; i < idx.count; i += 3) {
+            const a = idx.getX(i + 1);
+            idx.setX(i + 1, idx.getX(i + 2));
+            idx.setX(i + 2, a);
+        }
+    }
+    return face;
+}
+/** Per-vertex flags the asphalt shader reads (so tees, crosses and roundabouts merge into one mesh). */
+function tagAsphalt(g, tee, island) {
+    const n = g.getAttribute('position').count;
+    g.setAttribute('aTee', new THREE.BufferAttribute(new Float32Array(n).fill(tee ? 1 : 0), 1));
+    g.setAttribute('aRound', new THREE.BufferAttribute(new Float32Array(n).fill(island), 1));
+    return g;
+}
+const arc = (r, a0, a1, step = 0.07) => {
+    const n = Math.max(2, Math.ceil(Math.abs(a1 - a0) / step)), out = [];
+    for (let i = 0; i <= n; i++) {
+        const a = a0 + (a1 - a0) * i / n;
+        out.push([Math.cos(a) * r, Math.sin(a) * r]);
+    }
+    return out;
+};
+// ---------------------------------------------------------------------------- lab build
+export function build(u, c) {
+    const group = new THREE.Group();
+    // The asphalt's sun / texture / knob uniforms are the SHARED objects of `u` (a grid hands one set
+    // to every junction) while its lamp list is its own — otherwise all junctions sharing `u` would
+    // show the lamps gathered for whichever junction was gathered last.
+    const aU = Object.assign({}, u, createLampUniforms());
+    const asphalt = createMaterial(aU);
+    const pavU = createPavingUniforms();
+    const paving = createPavingMaterial(pavU);
+    const sigU = createSignalUniforms();
+    const signalMat = createSignalMaterial(sigU);
+    const fixU = createFixtureUniforms();
+    const fixture = createFixtureMaterial(fixU);
+    // A roundabout's island: the paving material in its lawn mode (its own material, so a grid merge keeps it apart).
+    const islU = createPavingUniforms();
+    islU.uGrassMix.value = 1;
+    islU.uPavColor.value.set('#3e6b25');
+    const island = createPavingMaterial(islU);
+    island.userData.mergeKey = 'lawn';
+    const meshes = [];
+    let lamps = [], lampLocal = [];
+    const state = { tex: null, walkTex: null, cycle: 14, t: 0 };
+    const clear = () => {
+        for (const m of meshes) {
+            group.remove(m);
+            m.geometry.dispose();
+        }
+        meshes.length = 0;
+        for (const L of lamps)
+            unregisterLamp(L);
+        lamps = [];
+        lampLocal = [];
+    };
+    const polyToSamples = (pts) => pts.map(([x, z], i) => {
+        const q = pts[(i + 1) % pts.length], p0 = pts[(i - 1 + pts.length) % pts.length];
+        const t = new THREE.Vector3(q[0] - p0[0], 0, q[1] - p0[1]).normalize();
+        return { p: new THREE.Vector3(x, 0, z), t, n: new THREE.Vector3(t.z, 0, -t.x), s: i };
+    });
+    // A roundabout: ring road around a raised lawn island, arms of the junction's lanes from the ring's
+    // outer edge (give-way lines, no signals), pavements following the circle between the arms, a
+    // lamp in each gap. Arms at +x, +z, -x and -z (roundabout3: no -z arm, like a T).
+    const buildRoundabout = (cfg, W, half, arm) => {
+        const ri = Math.max(2, cfg.islandRadius), ro = ri + W, L = junctionReach(cfg);
+        const three = cfg.shape === 'roundabout3';
+        const angles = three ? [0, Math.PI / 2, Math.PI] : [0, Math.PI / 2, Math.PI, Math.PI * 1.5];
+        const al = Math.asin(Math.min(0.99, half / ro)), x0 = Math.sqrt(ro * ro - half * half);
+        const rot = (a, [x, z]) => [x * Math.cos(a) - z * Math.sin(a), x * Math.sin(a) + z * Math.cos(a)];
+        // Asphalt: around the circle, out along each arm and back.
+        const outline = [];
+        angles.forEach((a, k) => {
+            const next = angles[(k + 1) % angles.length] + (k === angles.length - 1 ? Math.PI * 2 : 0);
+            outline.push(rot(a, [x0, -half]), rot(a, [L, -half]), rot(a, [L, half]), rot(a, [x0, half]));
+            outline.push(...arc(ro, a + al, next - al).slice(1, -1));
+        });
+        const asph = new THREE.Mesh(tagAsphalt(slabWithHoles(outline, [arc(ri, 0, Math.PI * 2).slice(0, -1)], 0.02), three, ri), asphalt);
+        asph.frustumCulled = false;
+        group.add(asph);
+        meshes.push(asph);
+        // Island: lawn at kerb height with its kerb.
+        const kh = Math.max(0.02, cfg.kerbHeight);
+        const ring = arc(ri, 0, Math.PI * 2);
+        const isl = new THREE.Mesh(mergeGeometries([slabWithHoles(ring.slice(0, -1), [], kh), kerbFace(ring, 0, kh, true)], [['aUV', 2]]), island);
+        isl.frustumCulled = false;
+        group.add(isl);
+        meshes.push(isl);
+        // Pavements between consecutive arms, along the circle; kerb on the road side.
+        if (cfg.sidewalk) {
+            const sw = 3, ro2 = ro + sw, al2 = Math.asin(Math.min(0.99, (half + sw) / ro2)), x1 = Math.sqrt(ro2 * ro2 - (half + sw) * (half + sw));
+            const parts = [];
+            angles.forEach((a, k) => {
+                const b2 = angles[(k + 1) % angles.length] + (k === angles.length - 1 ? Math.PI * 2 : 0);
+                const inner = [rot(a, [L, half]), rot(a, [x0, half]), ...arc(ro, a + al, b2 - al).slice(1, -1), rot(b2, [x0, -half]), rot(b2, [L, -half])];
+                const outer = [rot(b2, [L, -half - sw]), rot(b2, [x1, -half - sw]), ...arc(ro2, b2 - al2, a + al2).slice(1, -1), rot(a, [x1, half + sw]), rot(a, [L, half + sw])];
+                parts.push(slabWithHoles([...inner, ...outer], [], kh), kerbFace(inner, 0, kh, false));
+            });
+            const walk = new THREE.Mesh(mergeGeometries(parts, [['aUV', 2]]), paving);
+            walk.frustumCulled = false;
+            group.add(walk);
+            meshes.push(walk);
+        }
+        // Lamps: one in each gap between arms, on the pavement, arm over the ring.
+        if (cfg.lamps) {
+            const geo = buildLampGeometry({ height: cfg.lampHeight, armReach: 1.8 });
+            const lm = new THREE.InstancedMesh(geo, fixture, angles.length);
+            const m = new THREE.Matrix4(), q = new THREE.Quaternion(), p = new THREE.Vector3(), sc = new THREE.Vector3(1, 1, 1), up = new THREE.Vector3(0, 1, 0);
+            angles.forEach((a, k) => {
+                const b2 = angles[(k + 1) % angles.length] + (k === angles.length - 1 ? Math.PI * 2 : 0);
+                const mid = (a + b2) / 2, r = ro + 1.6;
+                p.set(Math.cos(mid) * r, 0, Math.sin(mid) * r);
+                q.setFromAxisAngle(up, Math.atan2(p.z, -p.x));
+                m.compose(p, q, sc);
+                lm.setMatrixAt(k, m);
+                const head = geo.userData.head.clone().applyMatrix4(m);
+                lampLocal.push(head);
+                lamps.push(registerLamp({ id: 'roundabout-' + k, position: head.clone(), color: new THREE.Color(cfg.lampColor), radius: cfg.lampRadius, intensity: cfg.lampIntensity, on: true }));
+            });
+            lm.instanceMatrix.needsUpdate = true;
+            lm.frustumCulled = false;
+            group.add(lm);
+            meshes.push(lm);
+        }
+    };
+    const rebuild = (cfg) => {
+        clear();
+        const lanes = Math.max(1, Math.round(cfg.lanes)), W = lanes * cfg.laneWidth, half = W / 2;
+        const arm = Math.max(cfg.armLength, 6), R = Math.max(0.5, cfg.cornerRadius);
+        const tee = cfg.shape === 'tee';
+        if (isRound(cfg.shape)) {
+            buildRoundabout(cfg, W, half, arm);
+            return;
+        }
+        // Asphalt slab (y = 0.02), UVs in metres.
+        const outline = asphaltOutline(half, arm, R, tee);
+        const slabGeo = slabGeometry(polyToSamples(outline), 0.02);
+        tagAsphalt(slabGeo, tee, 0);
+        const slab = new THREE.Mesh(slabGeo, asphalt);
+        slab.frustumCulled = false;
+        group.add(slab);
+        meshes.push(slab);
+        // Corner pavements + kerbs.
+        if (cfg.sidewalk) {
+            const kh = Math.max(0.02, cfg.kerbHeight);
+            const parts = [];
+            const corners = tee ? [[1, 1], [-1, 1]] : [[1, 1], [-1, 1], [-1, -1], [1, -1]];
+            for (const [sx, sz] of corners) {
+                const { outline: o, kerb } = cornerShape(sx, sz, half, arm, R);
+                const slabC = slabGeometry(polyToSamples(o), kh);
+                parts.push(slabC);
+                // Kerb face along the inner edge, facing the road (the arc centre side).
+                const ks = kerb.map(([x, z], i) => {
+                    const q = kerb[Math.min(i + 1, kerb.length - 1)], p0 = kerb[Math.max(i - 1, 0)];
+                    const t = new THREE.Vector3(q[0] - p0[0], 0, q[1] - p0[1]).normalize();
+                    return { p: new THREE.Vector3(x, 0, z), t, n: new THREE.Vector3(t.z, 0, -t.x), s: i * 1.5 };
+                });
+                const face = ribbon(ks, 0, 0, kh, 0.0, true, 1);
+                // Point the face toward the asphalt: flip if its normal points away from the junction centre.
+                const nrm = face.getAttribute('normal');
+                const p = face.getAttribute('position');
+                if (nrm.getX(0) * p.getX(0) + nrm.getZ(0) * p.getZ(0) > 0) {
+                    for (let i = 0; i < nrm.count; i++)
+                        nrm.setXYZ(i, -nrm.getX(i), 0, -nrm.getZ(i));
+                    const idx = face.index;
+                    for (let i = 0; i < idx.count; i += 3) {
+                        const a = idx.getX(i + 1);
+                        idx.setX(i + 1, idx.getX(i + 2));
+                        idx.setX(i + 2, a);
+                    }
+                }
+                parts.push(face);
+            }
+            if (tee) {
+                // A T keeps a straight pavement along the south side.
+                const L = half + arm;
+                const south = slabGeometry(polyToSamples([[-L, -half], [L, -half], [L, -half - 3], [-L, -half - 3]]), Math.max(0.02, cfg.kerbHeight));
+                parts.push(south);
+                const ks = [[-L, -half], [L, -half]].map(([x, z], i) => ({ p: new THREE.Vector3(x, 0, z), t: new THREE.Vector3(1, 0, 0), n: new THREE.Vector3(0, 0, -1), s: i * 2 * L }));
+                parts.push(ribbon(ks, 0, 0, Math.max(0.02, cfg.kerbHeight), 0.0, true, -1));
+            }
+            const walk = new THREE.Mesh(mergeGeometries(parts, [['aUV', 2]]), paving);
+            walk.frustumCulled = false;
+            group.add(walk);
+            meshes.push(walk);
+        }
+        // Signals: one per corner, on the pavement 1 m from the kerb, facing the arm whose traffic it controls.
+        if (cfg.signals) {
+            const parts = [];
+            const h = cfg.signalHeight;
+            const corners = tee ? [[1, 1], [-1, 1]] : [[1, 1], [-1, 1], [-1, -1], [1, -1]];
+            for (const [sx, sz] of corners) {
+                // The pole at the corner controls the arm it faces: traffic on the +x arm (coming toward -x) sees the head at corner (+x, -z)... keep it simple:
+                // each corner gets one head facing along -sx (controls the x arm on its side, group 0) and one facing -sz (z arm, group 1).
+                const px = sx * (half + 1.2), pz = sz * (half + 1.2);
+                parts.push(...signalGeometry(px, pz, new THREE.Vector3(sx, 0, 0), 0, h));
+                if (!(tee && sz < 0))
+                    parts.push(...signalGeometry(px + sx * 0.5, pz, new THREE.Vector3(0, 0, sz), 1, h));
+            }
+            const sig = new THREE.Mesh(mergeGeometries(parts, [['aLight', 1], ['aGroup', 1]]), signalMat);
+            sig.frustumCulled = false;
+            group.add(sig);
+            meshes.push(sig);
+        }
+        // Lamps: one per corner on the pavement, behind the signal pole, arm reaching over the kerb;
+        // registered in the lamp list so the asphalt, the pavements and nearby facades take their light.
+        if (cfg.lamps) {
+            const corners = tee ? [[1, 1], [-1, 1]] : [[1, 1], [-1, 1], [-1, -1], [1, -1]];
+            const geo = buildLampGeometry({ height: cfg.lampHeight, armReach: 1.8 });
+            const lm = new THREE.InstancedMesh(geo, fixture, corners.length);
+            const m = new THREE.Matrix4(), q = new THREE.Quaternion(), p = new THREE.Vector3(), sc = new THREE.Vector3(1, 1, 1), up = new THREE.Vector3(0, 1, 0);
+            corners.forEach(([sx, sz], i) => {
+                p.set(sx * (half + 3.2), 0, sz * (half + 3.2));
+                // The arm points at the junction centre (the lamp geometry's arm is along +x).
+                q.setFromAxisAngle(up, Math.atan2(sz, -sx));
+                m.compose(p, q, sc);
+                lm.setMatrixAt(i, m);
+                const head = geo.userData.head.clone().applyMatrix4(m);
+                lampLocal.push(head);
+                lamps.push(registerLamp({ id: 'junction-' + i, position: head.clone(), color: new THREE.Color(cfg.lampColor), radius: cfg.lampRadius, intensity: cfg.lampIntensity, on: true }));
+            });
+            lm.instanceMatrix.needsUpdate = true;
+            lm.frustumCulled = false;
+            group.add(lm);
+            meshes.push(lm);
+        }
+        state.cycle = Math.max(2, cfg.signalCycle);
+    };
+    const setTextures = (cfg) => {
+        const m = cfg.texture && cfg.texture.maps;
+        state.tex = m && m.color ? loadTextureSet(m) : null;
+        if (state.tex)
+            state.tex.ready.then(() => applyConfig(u, cfg, state.tex));
+        applyConfig(u, cfg, state.tex && state.tex.color ? state.tex : null);
+        const wm = cfg.sidewalkTexture && cfg.sidewalkTexture.maps;
+        state.walkTex = wm && wm.color ? loadTextureSet(wm) : null;
+        const ap = () => applyTextureSet(pavU, 'uPav', state.walkTex && state.walkTex.color ? state.walkTex : null, cfg.sidewalkTexture && cfg.sidewalkTexture.tileSize, 0.7);
+        if (state.walkTex)
+            state.walkTex.ready.then(ap);
+        ap();
+    };
+    const apply = (cfg) => {
+        applyConfig(u, cfg, undefined);
+        if (cfg.sidewalkColor !== undefined)
+            pavU.uPavColor.value.set(cfg.sidewalkColor);
+        if (cfg.signalPaint !== undefined)
+            sigU.uPaint.value.set(cfg.signalPaint);
+        if (cfg.signalCycle !== undefined)
+            state.cycle = Math.max(2, cfg.signalCycle);
+        if (cfg.lampPaint !== undefined)
+            fixU.uPaint.value.set(cfg.lampPaint);
+        if (cfg.lampColor !== undefined)
+            fixU.uLampColor.value.set(cfg.lampColor);
+        if (cfg.lampIntensity !== undefined)
+            fixU.uLampGlow.value = cfg.lampIntensity / 2.6;
+        setLamps(lamps, cfg.lampColor, cfg.lampIntensity, cfg.lampRadius); // bumps the lamp list only on a real change
+    };
+    rebuild(c);
+    setTextures(c);
+    apply(c);
+    const lastWorld = new THREE.Matrix4();
+    return {
+        object: group,
+        materials: [asphalt, paving, signalMat, fixture, island],
+        uniformSets: [u, pavU, sigU, fixU, islU],
+        /** Lamp gathering targets: the asphalt and the pavements, each with its own lamp list. */
+        lampTargets() { const b = this.bounds(); return [{ u: aU, bounds: b }, { u: pavU, bounds: b }, { u: islU, bounds: b }]; },
+        apply,
+        rebuild(cfg) { rebuild(cfg); setTextures(cfg); apply(cfg); },
+        bounds() { const b = new THREE.Box3(); for (const m of meshes) {
+            if (!m.geometry.boundingBox)
+                m.geometry.computeBoundingBox();
+            b.union(m.geometry.boundingBox);
+        } return b; },
+        update(dt) {
+            state.t += dt;
+            sigU.uPhase.value = (state.t / state.cycle) % 1;
+            // Keep the registry's world positions in step with the object's transform.
+            group.updateMatrixWorld();
+            if (!lastWorld.equals(group.matrixWorld)) {
+                lastWorld.copy(group.matrixWorld);
+                placeLamps(lamps, lampLocal, group.matrixWorld); // positions, reach and falloff follow the object's scale
+                if (lamps.length)
+                    touchLamps();
+            }
+        },
+        dispose() { clear(); asphalt.dispose(); paving.dispose(); signalMat.dispose(); fixture.dispose(); island.dispose(); },
+    };
+}