@3driseai/3drise-viewer 0.1.42 → 0.1.44

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

@@ -0,0 +1,347 @@
+// Emitted from Claude outputs/urban-lab/road.mjs by emit_object.mjs — edit the lab module and re-emit.
+// =============================================================================
+// urban/road — a street along a polyline: lanes, markings, kerbs, sidewalks, lamps
+// =============================================================================
+// Construction. The polyline (config.points, metres in the object's XZ) is run through a
+// Catmull-Rom spline (the `curve` knob is its tension: 0 keeps the corners, 1 rounds them)
+// and sampled every ~1.5 m. Each sample gives a frame (tangent, right normal) and the
+// ribbons are swept along it: asphalt [-W/2, W/2], a kerb face up to kerbHeight, the
+// sidewalk slab and its outer face. Every vertex carries (s, t): metres along and across
+// the road, so markings live in the fragment shader — centre line (dashed / solid /
+// double), lane dashes, edge lines, zebra crossings at both ends — anti-aliased with
+// fwidth, worn by a hash along s. Tyre tracks darken the wheel paths of every lane.
+//
+// Light. Asphalt and paving are library texture sets normalised to their mean (the colour
+// knob decides). Street lamps every lampSpacing metres are instances of the shared lamp
+// fixture; their heads are emissive and they are REGISTERED in the lamp list — the road's
+// own asphalt and sidewalks, nearby facades and other roads light themselves from it.
+// No THREE light anywhere.
+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, buildLampGeometry, createFixtureUniforms, createFixtureMaterial, registerLamp, unregisterLamp, touchLamps, setLamps, placeLamps, mergeGeometries, samplePath, ribbon, SURFACE_DEPTH, } from '../urbanCore.js';
+export const MARKINGS = ['dashed', 'solid', 'double', 'none'];
+export const LAMP_SIDES = ['both', 'left', 'right', 'alternate', 'none'];
+export const LIGHTING = ['auto', 'day', 'night'];
+export const STRUCTURAL = ['points', 'curve', 'lanes', 'laneWidth', 'sidewalk', 'kerbHeight', 'lampSpacing', 'lampSide', 'lampHeight', 'seed', 'texture', 'sidewalkTexture'];
+// ---------------------------------------------------------------------------- path
+export function roadWidth(c) { return Math.max(1, Math.round(c.lanes)) * c.laneWidth; }
+/** Where the lamps stand: [{ x, z, ry, side }] in object space (head arm turned toward the road). */
+export function lampPositions(c, samples) {
+    const out = [];
+    if (!samples.length || !(c.lampSpacing > 0) || c.lampSide === 'none')
+        return out;
+    const W = roadWidth(c);
+    const setback = c.sidewalk > 0.5 ? W / 2 + Math.min(c.sidewalk * 0.45, 1.2) : W / 2 + 0.8;
+    const L = samples[samples.length - 1].s;
+    const count = Math.max(1, Math.floor(L / c.lampSpacing));
+    const start = (L - (count - 1) * c.lampSpacing) / 2;
+    let k = 0;
+    for (let i = 0; i < count; i++) {
+        const s = start + i * c.lampSpacing;
+        let j = 0;
+        while (j < samples.length - 1 && samples[j + 1].s < s)
+            j++;
+        const S = samples[j];
+        const sides = c.lampSide === 'both' ? [1, -1] : c.lampSide === 'left' ? [-1] : c.lampSide === 'right' ? [1] : [k++ % 2 === 0 ? 1 : -1];
+        for (const side of sides) {
+            const x = S.p.x + S.n.x * setback * side, z = S.p.z + S.n.z * setback * side;
+            // The fixture's arm points along +x: aim it at the road (opposite the side normal).
+            const ax = -S.n.x * side, az = -S.n.z * side;
+            out.push({ x, z, ry: Math.atan2(-az, ax), side });
+        }
+    }
+    return out;
+}
+// ---------------------------------------------------------------------------- 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 },
+        uMarking: { value: 0 },
+        uLaneLines: { value: 1 },
+        uEdgeLines: { value: 1 },
+        uCrosswalks: { value: 1 },
+        uWear: { value: 0.5 },
+        uLength: { value: 100 },
+        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.markings !== undefined)
+        u.uMarking.value = MARKINGS.indexOf(c.markings);
+    if (c.laneLines !== undefined)
+        u.uLaneLines.value = c.laneLines ? 1 : 0;
+    if (c.edgeLines !== undefined)
+        u.uEdgeLines.value = c.edgeLines ? 1 : 0;
+    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 = roadWidth(c);
+    }
+    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;
+varying vec3 vN; varying vec3 vP; varying vec2 vST;
+${GLSL_FOG_VERT_PARS}
+void main() {
+    vec4 wp = modelMatrix * vec4(position, 1.0);
+    vP = wp.xyz;
+    vN = normalize(mat3(modelMatrix) * normal);
+    vST = aUV;
+    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 uMarking;
+uniform float uLaneLines; uniform float uEdgeLines; uniform float uCrosswalks; uniform float uWear; uniform float uLength; uniform float uSeed;
+varying vec3 vN; varying vec3 vP; varying vec2 vST;
+${GLSL_FOG_PARS}
+
+// A painted line of width w centred on x = 0, anti-aliased.
+float lineAA(float x, float w) { return 1.0 - bandAA(abs(x), w * 0.5, 1e9); }
+// 3 m dash, 9 m gap, anti-aliased along s.
+float dashAA(float s) { float m = mod(s, 12.0); return bandAA(m, 0.0, 3.0); }
+
+void main() {
+    vec3 N = normalize(vN);
+    vec3 V = normalize(cameraPosition - vP);
+    float s = vST.x, t = vST.y;
+    // Texture along the road: u = s, v = t (so the asphalt grain follows the lanes).
+    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(vec2(s, t), Nb, T, B, rough);
+    // Wheel tracks: two darker paths per lane, 0.9 m either side of the lane centre.
+    float lanePos = mod(t + uWidth * 0.5, uLaneWidth) - uLaneWidth * 0.5;
+    float tracks = exp(-pow((abs(lanePos) - 0.9) / 0.45, 2.0));
+    float macro = 0.92 + 0.16 * vnoise21(vec2(s, t) / 9.0 + uSeed);
+    vec3 albedo = uAsphaltColor * mul * macro * (1.0 - 0.22 * uWear * tracks);
+    rough = mix(rough, 0.95, 0.4) - 0.1 * uWear * tracks;
+
+    // Markings ---------------------------------------------------------------
+    float lw = 0.12;
+    float mark = 0.0;
+    // Centre line (between the two middle lanes when the lane count is even; the middle of the middle lane is never painted when odd).
+    float even = 1.0 - mod(uLanes, 2.0);
+    float centre = lineAA(t, lw);
+    if (uMarking < 0.5) centre *= dashAA(s);
+    else if (uMarking > 1.5 && uMarking < 2.5) centre = lineAA(abs(t) - 0.11, lw);
+    else if (uMarking > 2.5) centre = 0.0;
+    mark += centre * even;
+    // Lane lines: dashed at every lane boundary except the centre line and the two edges.
+    float bPos = mod(t + uWidth * 0.5 + uLaneWidth * 0.5, uLaneWidth) - uLaneWidth * 0.5;   // 0 at a boundary
+    float boundary = lineAA(bPos, lw) * dashAA(s + 6.0);
+    float notCentre = 1.0 - step(abs(t), uLaneWidth * 0.25) * even;
+    float notEdge = 1.0 - step(uWidth * 0.5 - uLaneWidth * 0.25, abs(t));
+    mark += boundary * uLaneLines * notCentre * notEdge;
+    // Edge lines, solid, 0.3 m in from the kerb.
+    mark += lineAA(abs(t) - (uWidth * 0.5 - 0.3), lw) * uEdgeLines;
+    // Zebra crossings at both ends: 3 m of 0.5 m stripes across the road, 2 m from the end.
+    float endDist = min(s, uLength - s);
+    float zebraZone = bandAA(endDist, 2.0, 5.0);
+    float stripes = bandAA(mod(t + uWidth * 0.5, 1.0), 0.0, 0.5);
+    float zebra = zebraZone * stripes * uCrosswalks;
+    // The stop line before each crossing.
+    zebra = max(zebra, bandAA(endDist, 5.4, 5.75) * uCrosswalks);
+    mark = clamp(max(mark, zebra), 0.0, 1.0);
+    // Paint wear: chips along s and fading where the tyres run.
+    float chip = hash21(floor(vec2(s * 2.0, t * 4.0)) + uSeed);
+    float wear = uWear * (0.35 * step(chip, 0.25 * uWear) + 0.5 * tracks);
+    mark *= 1.0 - clamp(wear, 0.0, 0.85);
+    vec3 paint = uMarkingColor * mix(1.0, 0.75, chip * uWear);
+    albedo = mix(albedo, paint, 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 });
+}
+// ---------------------------------------------------------------------------- lab build
+/**
+ * build(u, c) -> { object, materials, apply, rebuild, update, dispose, bounds, lamps }
+ * `u` is the asphalt uniforms; the paving and fixture uniforms are created here and share
+ * the sun / lamp values through applySun on all three (the component does the same).
+ */
+export const CHUNK_M = 120; // a long road is drawn in chunks so each one gathers its own lamps
+export function build(u, c) {
+    const group = new THREE.Group();
+    const pavU = createPavingUniforms();
+    const fixU = createFixtureUniforms();
+    const fixture = createFixtureMaterial(fixU);
+    // Per chunk: one asphalt + one paving material whose sun / texture / knob uniforms are the
+    // SHARED objects (u / pavU) and whose lamp uniforms are its own.
+    const chunks = []; // { road, walk, u, pavU, bounds }
+    let lampMesh = null;
+    let lamps = []; // registry entries
+    let lampLocal = []; // head positions in object space
+    const state = { tex: null, walkTex: null, samples: [] };
+    const clear = () => {
+        for (const ch of chunks) {
+            for (const m of [ch.road, ch.walk])
+                if (m) {
+                    group.remove(m);
+                    m.geometry.dispose();
+                    m.material.dispose();
+                }
+        }
+        chunks.length = 0;
+        if (lampMesh) {
+            group.remove(lampMesh);
+            lampMesh.geometry.dispose();
+            lampMesh = null;
+        }
+        for (const L of lamps)
+            unregisterLamp(L);
+        lamps = [];
+        lampLocal = [];
+    };
+    const rebuild = (cfg) => {
+        clear();
+        const samples = samplePath(cfg.points, cfg.curve);
+        state.samples = samples;
+        if (samples.length < 2)
+            return;
+        const W = roadWidth(cfg);
+        u.uLength.value = samples[samples.length - 1].s;
+        const L = samples[samples.length - 1].s;
+        const nChunks = Math.max(1, Math.ceil(L / CHUNK_M));
+        for (let k = 0; k < nChunks; k++) {
+            const s0 = (k * L) / nChunks, s1 = ((k + 1) * L) / nChunks;
+            let i0 = 0;
+            while (i0 < samples.length - 1 && samples[i0 + 1].s <= s0)
+                i0++;
+            let i1 = i0;
+            while (i1 < samples.length - 1 && samples[i1].s < s1)
+                i1++;
+            const part = samples.slice(i0, i1 + 1);
+            if (part.length < 2)
+                continue;
+            const chU = Object.assign({}, u, createLampUniforms());
+            const road = new THREE.Mesh(ribbon(part, -W / 2, W / 2, 0.02, 0.02, false), createMaterial(chU));
+            road.frustumCulled = false;
+            group.add(road);
+            const ch = { road, walk: null, u: chU, pavU: null, bounds: new THREE.Box3() };
+            road.geometry.computeBoundingBox();
+            ch.bounds.union(road.geometry.boundingBox);
+            if (cfg.sidewalk > 0.05) {
+                const kh = Math.max(0, cfg.kerbHeight), sw = cfg.sidewalk;
+                const parts = [
+                    ribbon(part, W / 2, W / 2, 0.0, kh, true, -1), // right kerb face (toward the road)
+                    ribbon(part, W / 2, W / 2 + sw, kh, kh, false), // right slab
+                    ribbon(part, W / 2 + sw, W / 2 + sw, kh, 0.0, true, 1), // right outer drop
+                    ribbon(part, -W / 2, -W / 2, kh, 0.0, true, -1), // left kerb face
+                    ribbon(part, -W / 2 - sw, -W / 2, kh, kh, false), // left slab
+                    ribbon(part, -W / 2 - sw, -W / 2 - sw, 0.0, kh, true, 1), // left outer drop
+                ];
+                ch.pavU = Object.assign({}, pavU, createLampUniforms());
+                ch.walk = new THREE.Mesh(mergeGeometries(parts, [['aUV', 2]]), createPavingMaterial(ch.pavU));
+                ch.walk.frustumCulled = false;
+                group.add(ch.walk);
+                ch.bounds.union(ch.walk.geometry.boundingBox);
+            }
+            chunks.push(ch);
+        }
+        // Lamps: one fixture geometry, instanced.
+        const where = lampPositions(cfg, samples);
+        if (where.length) {
+            const geo = buildLampGeometry({ height: cfg.lampHeight, armReach: 1.8 });
+            lampMesh = new THREE.InstancedMesh(geo, fixture, where.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);
+            for (let i = 0; i < where.length; i++) {
+                const w = where[i];
+                p.set(w.x, 0, w.z);
+                q.setFromAxisAngle(up, w.ry);
+                m.compose(p, q, sc);
+                lampMesh.setMatrixAt(i, m);
+                const head = geo.userData.head.clone().applyMatrix4(m);
+                lampLocal.push(head);
+                lamps.push(registerLamp({ id: 'road-' + i, position: head.clone(), color: new THREE.Color(cfg.lampColor), radius: cfg.lampRadius, intensity: cfg.lampIntensity, on: true }));
+            }
+            lampMesh.instanceMatrix.needsUpdate = true;
+            lampMesh.frustumCulled = false;
+            group.add(lampMesh);
+        }
+    };
+    const setTextures = (cfg) => {
+        const maps = cfg.texture && cfg.texture.maps;
+        state.tex = maps && maps.color ? loadTextureSet(maps) : 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 applyWalk = () => 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(applyWalk);
+        applyWalk();
+    };
+    const apply = (cfg) => {
+        applyConfig(u, cfg, undefined);
+        if (cfg.sidewalkColor !== undefined)
+            pavU.uPavColor.value.set(cfg.sidewalkColor);
+        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,
+        get materials() { const out = [fixture]; for (const ch of chunks) {
+            out.push(ch.road.material);
+            if (ch.walk)
+                out.push(ch.walk.material);
+        } return out; },
+        /** The shared uniform sets (sun goes here once; the chunks reference the same objects). */
+        uniformSets: [u, pavU, fixU],
+        /** Lamp gathering targets: each chunk's asphalt and paving with its local bounds. */
+        lampTargets() { const out = []; for (const ch of chunks) {
+            out.push({ u: ch.u, bounds: ch.bounds });
+            if (ch.pavU)
+                out.push({ u: ch.pavU, bounds: ch.bounds });
+        } return out; },
+        apply,
+        rebuild(cfg) { rebuild(cfg); setTextures(cfg); apply(cfg); },
+        /** Local-space bounds (the caller applies the object's world matrix). */
+        bounds() { const b = new THREE.Box3(); for (const ch of chunks)
+            b.union(ch.bounds); return b; },
+        /** Keep the registry's world positions in step with the object's transform. */
+        update() {
+            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(); fixture.dispose(); },
+    };
+}

package/dist/components/urban/core/signage.d.ts

@@ -0,0 +1,83 @@
+import * as THREE from 'three';
+export declare const KINDS: string[];
+export declare const LIGHTING: string[];
+export declare const STRUCTURAL: string[];
+export declare function createUniforms(): {
+    uSunDir: {
+        value: THREE.Vector3;
+    };
+    uSunColor: {
+        value: THREE.Color;
+    };
+    uSkyAmbient: {
+        value: THREE.Color;
+    };
+    uGroundAmbient: {
+        value: THREE.Color;
+    };
+    uNight: {
+        value: number;
+    };
+} & {
+    uLamps: {
+        value: any[];
+    };
+    uLampColors: {
+        value: any[];
+    };
+    uLampAims: {
+        value: any[];
+    };
+    uLampCount: {
+        value: number;
+    };
+    uLampTop: {
+        value: number;
+    };
+    uLampField: {
+        value: any;
+    };
+    uLampFieldRect: {
+        value: THREE.Vector4;
+    };
+    uLampFieldOn: {
+        value: number;
+    };
+} & {
+    uImage: {
+        value: THREE.DataTexture;
+    };
+    uHasImage: {
+        value: number;
+    };
+    uImageAspect: {
+        value: number;
+    };
+    uPanelAspect: {
+        value: number;
+    };
+    uColor: {
+        value: THREE.Color;
+    };
+    uFrame: {
+        value: THREE.Color;
+    };
+    uGlow: {
+        value: number;
+    };
+};
+export declare function applyConfig(u: any, c: any): void;
+export declare const VERT = "\nvarying vec3 vN; varying vec3 vP; varying vec2 vUv;\n#include <fog_pars_vertex>\nvoid main() {\n    vec4 wp = modelMatrix * vec4(position, 1.0);\n    vP = wp.xyz; vN = normalize(mat3(modelMatrix) * normal); vUv = uv;\n    vec4 mvPosition = viewMatrix * wp;\n    gl_Position = projectionMatrix * mvPosition;\n    #include <fog_vertex>\n}";
+export declare const FRAG = "\nprecision highp float;\n\nuniform vec3 uSunDir;\nuniform vec3 uSunColor;\nuniform vec3 uSkyAmbient;\nuniform vec3 uGroundAmbient;\nuniform float uNight;\nuniform vec4 uLamps[48];\nuniform vec4 uLampColors[48];\nuniform vec4 uLampAims[48];\nuniform int uLampCount;\nuniform float uLampTop;\nuniform sampler2D uLampField;\nuniform vec4 uLampFieldRect;\nuniform float uLampFieldOn;\n\nfloat hash11(float p) { p = fract(p * 0.1031); p *= p + 33.33; p *= p + p; return fract(p); }\nfloat 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); }\nfloat 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); }\nfloat hash31(vec3 p) { p = fract(p * 0.1031); p += dot(p, p.zyx + 31.32); return fract((p.x + p.y) * p.z); }\n\n// Irradiance from the gathered lamps. Each lamp is a downward-facing head: a smooth\n// window to its radius, inverse-square falloff softened near the head, a cosine cone so\n// it pools on the ground and only grazes walls, Lambert on the receiver. Scaled by the\n// night factor so pools fade in with dusk.\nvec3 lampLight(vec3 P, vec3 N) {\n    vec3 acc = vec3(0.0);\n    if (uNight < 0.002) return acc;\n    // A baked lamp field (a street grid): the ground's light at this xz, decoded; walls take a share.\n    if (uLampFieldOn > 0.5) {\n        vec3 e = texture2D(uLampField, (P.xz - uLampFieldRect.xy) / uLampFieldRect.zw).rgb;\n        return e * e * 4.0 * (0.3 + 0.7 * max(N.y, 0.0)) * uNight;\n    }\n    // Above the reach of every gathered lamp (most of a facade) the loop is skipped.\n    if (P.y > uLampTop) return acc;\n    for (int i = 0; i < 48; i++) {\n        if (i >= uLampCount) break;\n        vec4 L = uLamps[i];\n        vec3 d = L.xyz - P;\n        float r2 = dot(d, d);\n        float r = sqrt(r2);\n        vec3 l = d / max(r, 1e-3);\n        float x = r / L.w;\n        float win = clamp(1.0 - x * x * x * x, 0.0, 1.0);\n        win *= win;\n        float ndl = max(dot(N, l), 0.0);\n        vec4 A = uLampAims[i];\n        if (A.w > 0.0) {\n            // a projector: an aimed beam (soft edge from the outer cone in), throw nearly flat over its\n            // reach, so a few towers light a whole stadium evenly; walls facing it take light too\n            float spot = smoothstep(A.w, mix(A.w, 1.0, 0.45), dot(-l, A.xyz));\n            acc += uLampColors[i].rgb * (uLampColors[i].a * win * spot * (0.35 + 0.65 * ndl) * 4.0 / (1.0 + x * x * 3.0));\n            continue;\n        }\n        float cone = smoothstep(0.1, 0.7, l.y);\n        float ls = A.w < 0.0 ? -A.w : 1.0;   // the lamp's object scale: falloff over its own metres\n        // Intensity 1 puts ~0.75 irradiance on the ground under an 8 m head, a tenth of that\n        // 14 m along the kerb: street-lamp contrast, not a wash.\n        acc += uLampColors[i].rgb * (uLampColors[i].a * win * ndl * cone * 4.0 / (1.0 + r2 * 0.06 / (ls * ls)));\n    }\n    return acc * uNight;\n}\n\n// Sun + sky + ground + lamps on a rough dielectric. Radiance units: a 0.5 albedo at noon\n// lands near 0.9, so NoToneMapping keeps it under 1.\nvec3 shadeSurface(vec3 albedo, vec3 N, vec3 P, vec3 V, float rough, float ao) {\n    float ndl = max(dot(N, uSunDir), 0.0);\n    vec3 sky = uSkyAmbient * (0.55 + 0.45 * N.y);\n    vec3 gnd = uGroundAmbient * (0.5 - 0.5 * N.y);\n    vec3 col = albedo * (uSunColor * ndl + (sky + gnd) * ao);\n    vec3 H = normalize(uSunDir + V);\n    float spec = pow(max(dot(N, H), 0.0), mix(90.0, 6.0, rough)) * (1.0 - rough) * 0.35 * ndl;\n    col += uSunColor * spec;\n    col += albedo * lampLight(P, N);\n    return col;\n}\n\n// Box-filtered coverage of the band [a, b] over this pixel's footprint on x: exact\n// anti-aliasing at the edge AND the right average when the band is thinner than a pixel\n// (a far facade blends to the mean of glass and spandrel instead of sparkling).\nfloat bandAA(float x, float a, float b) {\n    float w = max(fwidth(x), 1e-5);\n    float lo = max(a, x - 0.5 * w), hi = min(b, x + 0.5 * w);\n    return clamp((hi - lo) / w, 0.0, 1.0);\n}\n\nuniform sampler2D uImage; uniform float uHasImage; uniform float uImageAspect; uniform float uPanelAspect;\nuniform vec3 uColor; uniform vec3 uFrame; uniform float uGlow;\nvarying vec3 vN; varying vec3 vP; varying vec2 vUv;\n#include <fog_pars_fragment>\nvoid main() {\n    vec3 N = normalize(vN);\n    if (!gl_FrontFacing) N = -N;\n    vec3 V = normalize(cameraPosition - vP);\n    // Frame: a 3 % border; inside it the picture, fitted to cover the panel.\n    vec2 b = vec2(0.03 / uPanelAspect * 2.0, 0.03);\n    float inside = bandAA(vUv.x, b.x, 1.0 - b.x) * bandAA(vUv.y, b.y, 1.0 - b.y);\n    vec2 uv = (vUv - b) / (1.0 - 2.0 * b);\n    float r = uPanelAspect / max(uImageAspect, 0.01);\n    vec2 cuv = r > 1.0 ? vec2(uv.x, (uv.y - 0.5) / r + 0.5) : vec2((uv.x - 0.5) * r + 0.5, uv.y);\n    vec3 pic = mix(uColor, texture2D(uImage, cuv).rgb, uHasImage);\n    // Day: a matte print lit by the scene. Night: the print itself glows (backlit box).\n    vec3 lit = shadeSurface(pic, N, vP, V, 0.7, 1.0);\n    vec3 glow = pic * (0.9 + 1.1 * uGlow) * uNight;\n    vec3 face = lit + glow;\n    vec3 frame = shadeSurface(uFrame, N, vP, V, 0.5, 1.0);\n    vec3 col = mix(frame, face, inside);\n\n    gl_FragColor = vec4(col, 1.0);\n    #include <tonemapping_fragment>\n    #include <colorspace_fragment>\n    #include <fog_fragment>\n\n}";
+export declare function createMaterial(u: any, doubleSided: any): THREE.ShaderMaterial;
+export declare function build(u: any, c: any): {
+    object: THREE.Group<THREE.Object3DEventMap>;
+    materials: THREE.ShaderMaterial[];
+    uniformSets: any[];
+    apply: (cfg: any) => void;
+    rebuild(cfg: any): void;
+    bounds(): THREE.Box3;
+    update(): void;
+    dispose(): void;
+};
+//# sourceMappingURL=signage.d.ts.map

package/dist/components/urban/core/signage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signage.d.ts","sourceRoot":"","sources":["../../../../src/components/urban/core/signage.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAM/B,eAAO,MAAM,KAAK,UAAoC,CAAC;AACvD,eAAO,MAAM,QAAQ,UAA2B,CAAC;AAEjD,eAAO,MAAM,UAAU,UAA0D,CAAC;AAclF,wBAAgB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAU7B;AAED,wBAAgB,WAAW,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA,QAK/B;AAED,eAAO,MAAM,IAAI,uVASf,CAAC;AACH,eAAO,MAAM,IAAI,m8KAyBf,CAAC;AACH,wBAAgB,cAAc,CAAC,CAAC,KAAA,EAAE,WAAW,KAAA,wBAE5C;AA8BD,wBAAgB,KAAK,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA;;;;;;;;;EAkDzB"}

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

@@ -0,0 +1,209 @@
+// Emitted from Claude outputs/urban-lab/signage.mjs by emit_object.mjs — edit the lab module and re-emit.
+// =============================================================================
+// urban/signage — billboard, totem or rooftop sign carrying a picture, backlit at night
+// =============================================================================
+// Construction. A panel (width x height) with a frame, carried by its kind: billboard = two
+// posts to `elevation`; totem = a tall narrow panel on a plinth at ground level; rooftop =
+// an open truss frame to `elevation` (place the object on a roof). The panel's fragment
+// shader fits the picture (cover) inside the frame over a background colour; by day it is
+// a lit print (sun + sky through the shared sun block), at night a backlit box: the picture
+// itself emits (glow), so it reads from across the street, and it registers as a weak lamp
+// so the pavement below picks up its light. No real light. The posts and frame use the
+// family's fixture material.
+import * as THREE from 'three';
+import { createSunUniforms, createLampUniforms, GLSL_COMMON, GLSL_FOG_PARS, GLSL_FOG_VERT_PARS, GLSL_OUT, createFixtureUniforms, createFixtureMaterial, mergeGeometries, registerLamp, unregisterLamp, touchLamps, setLamps, placeLamps, } from '../urbanCore.js';
+export const KINDS = ['billboard', 'totem', 'rooftop'];
+export const LIGHTING = ['auto', 'day', 'night'];
+export const STRUCTURAL = ['kind', 'width', 'height', 'elevation', 'doubleSided'];
+// ---------------------------------------------------------------------------- panel material
+const _none = (() => { const t = new THREE.DataTexture(new Uint8Array([0, 0, 0, 0]), 1, 1); t.needsUpdate = true; return t; })();
+const _imgCache = new Map();
+function loadImage(url, onLoad) {
+    if (!url)
+        return null;
+    if (_imgCache.has(url)) {
+        const t = _imgCache.get(url);
+        onLoad(t);
+        return t;
+    }
+    const loader = new THREE.TextureLoader();
+    loader.setCrossOrigin('anonymous');
+    const t = loader.load(url, (tex) => { tex.colorSpace = THREE.SRGBColorSpace; tex.anisotropy = 8; onLoad(tex); });
+    _imgCache.set(url, t);
+    return t;
+}
+export function createUniforms() {
+    return Object.assign(createSunUniforms(), createLampUniforms(), {
+        uImage: { value: _none },
+        uHasImage: { value: 0 },
+        uImageAspect: { value: 1 },
+        uPanelAspect: { value: 2 },
+        uColor: { value: new THREE.Color() },
+        uFrame: { value: new THREE.Color() },
+        uGlow: { value: 1 },
+    });
+}
+export function applyConfig(u, c) {
+    if (c.color !== undefined)
+        u.uColor.value.set(c.color);
+    if (c.frameColor !== undefined)
+        u.uFrame.value.set(c.frameColor);
+    if (c.glow !== undefined)
+        u.uGlow.value = c.glow;
+    if (c.width !== undefined && c.height !== undefined)
+        u.uPanelAspect.value = c.width / Math.max(c.height, 0.01);
+}
+export const VERT = /* glsl */ `
+varying vec3 vN; varying vec3 vP; varying vec2 vUv;
+${GLSL_FOG_VERT_PARS}
+void main() {
+    vec4 wp = modelMatrix * vec4(position, 1.0);
+    vP = wp.xyz; vN = normalize(mat3(modelMatrix) * normal); vUv = uv;
+    vec4 mvPosition = viewMatrix * wp;
+    gl_Position = projectionMatrix * mvPosition;
+    #include <fog_vertex>
+}`;
+export const FRAG = /* glsl */ `
+precision highp float;
+${GLSL_COMMON}
+uniform sampler2D uImage; uniform float uHasImage; uniform float uImageAspect; uniform float uPanelAspect;
+uniform vec3 uColor; uniform vec3 uFrame; uniform float uGlow;
+varying vec3 vN; varying vec3 vP; varying vec2 vUv;
+${GLSL_FOG_PARS}
+void main() {
+    vec3 N = normalize(vN);
+    if (!gl_FrontFacing) N = -N;
+    vec3 V = normalize(cameraPosition - vP);
+    // Frame: a 3 % border; inside it the picture, fitted to cover the panel.
+    vec2 b = vec2(0.03 / uPanelAspect * 2.0, 0.03);
+    float inside = bandAA(vUv.x, b.x, 1.0 - b.x) * bandAA(vUv.y, b.y, 1.0 - b.y);
+    vec2 uv = (vUv - b) / (1.0 - 2.0 * b);
+    float r = uPanelAspect / max(uImageAspect, 0.01);
+    vec2 cuv = r > 1.0 ? vec2(uv.x, (uv.y - 0.5) / r + 0.5) : vec2((uv.x - 0.5) * r + 0.5, uv.y);
+    vec3 pic = mix(uColor, texture2D(uImage, cuv).rgb, uHasImage);
+    // Day: a matte print lit by the scene. Night: the print itself glows (backlit box).
+    vec3 lit = shadeSurface(pic, N, vP, V, 0.7, 1.0);
+    vec3 glow = pic * (0.9 + 1.1 * uGlow) * uNight;
+    vec3 face = lit + glow;
+    vec3 frame = shadeSurface(uFrame, N, vP, V, 0.5, 1.0);
+    vec3 col = mix(frame, face, inside);
+${GLSL_OUT}
+}`;
+export function createMaterial(u, doubleSided) {
+    return new THREE.ShaderMaterial({ uniforms: Object.assign(THREE.UniformsUtils.clone(THREE.UniformsLib.fog), u), vertexShader: VERT, fragmentShader: FRAG, fog: true, side: doubleSided ? THREE.DoubleSide : THREE.FrontSide });
+}
+// ---------------------------------------------------------------------------- geometry
+const box = (w, h, d, x, y, z) => { const g = new THREE.BoxGeometry(w, h, d); g.translate(x, y, z); return g; };
+/** The carrier for a kind: { frame (fixture geometry), panelY (centre height), panelZ } */
+function carrier(kind, w, h, elev) {
+    const parts = [];
+    if (kind === 'billboard') {
+        const y0 = Math.max(elev, 0.5);
+        for (const sx of [-w * 0.3, w * 0.3])
+            parts.push(new THREE.CylinderGeometry(0.12, 0.16, y0 + h * 0.5, 12).translate(sx, (y0 + h * 0.5) / 2, -0.25));
+        parts.push(box(w * 0.7, 0.12, 0.12, 0, y0 + 0.1, -0.25));
+        return { frame: parts, panelY: y0 + h / 2, panelZ: 0 };
+    }
+    if (kind === 'totem') {
+        parts.push(box(w * 1.1, 0.25, 0.8, 0, 0.125, 0));
+        return { frame: parts, panelY: 0.25 + h / 2, panelZ: 0 };
+    }
+    // rooftop: a light truss of posts and diagonals up to the elevation
+    const y0 = Math.max(elev, 0.5);
+    const n = Math.max(2, Math.round(w / 2.5));
+    for (let i = 0; i < n; i++) {
+        const x = -w / 2 + (i + 0.5) * (w / n);
+        parts.push(new THREE.CylinderGeometry(0.05, 0.05, y0, 8).translate(x, y0 / 2, -0.2));
+        parts.push(new THREE.CylinderGeometry(0.04, 0.04, y0, 8).translate(x, y0 / 2, -1.0));
+        const diag = new THREE.CylinderGeometry(0.03, 0.03, Math.hypot(y0, 0.8), 6);
+        diag.rotateX(Math.atan2(0.8, y0));
+        diag.translate(x, y0 / 2, -0.6);
+        parts.push(diag);
+    }
+    parts.push(box(w, 0.06, 1.0, 0, y0, -0.6));
+    return { frame: parts, panelY: y0 + h / 2, panelZ: 0 };
+}
+export function build(u, c) {
+    const group = new THREE.Group();
+    const panelMat = createMaterial(u, c.doubleSided);
+    const fixU = createFixtureUniforms();
+    const fixture = createFixtureMaterial(fixU);
+    let panel = null, frame = null, lamp = null, headLocal = null, img = null;
+    const clear = () => {
+        for (const m of [panel, frame])
+            if (m) {
+                group.remove(m);
+                m.geometry.dispose();
+            }
+        panel = frame = null;
+        if (lamp) {
+            unregisterLamp(lamp);
+            lamp = null;
+        }
+    };
+    const rebuild = (cfg) => {
+        clear();
+        const w = Math.max(0.3, cfg.width), h = Math.max(0.3, cfg.height);
+        const car = carrier(cfg.kind, w, h, cfg.elevation);
+        panelMat.side = cfg.doubleSided ? THREE.DoubleSide : THREE.FrontSide;
+        panelMat.needsUpdate = true;
+        panel = new THREE.Mesh(new THREE.PlaneGeometry(w, h), panelMat);
+        panel.position.set(0, car.panelY, car.panelZ);
+        group.add(panel);
+        if (car.frame.length) {
+            frame = new THREE.Mesh(mergeGeometries(car.frame, [['aEmissive', 1], ['aAccent', 1]]), fixture);
+            group.add(frame);
+        }
+        headLocal = new THREE.Vector3(0, car.panelY - h * 0.3, 1.0);
+        lamp = registerLamp({ id: 'sign', position: headLocal.clone(), color: new THREE.Color(cfg.color).lerp(new THREE.Color('#ffffff'), 0.6), radius: Math.max(6, w * 1.2), intensity: 0.5 * cfg.glow, on: true });
+    };
+    const setImage = (cfg) => {
+        const url = cfg.imageUrl || '';
+        if (!url) {
+            u.uImage.value = _none;
+            u.uHasImage.value = 0;
+            img = null;
+            return;
+        }
+        img = loadImage(url, (t) => { u.uImage.value = t; u.uHasImage.value = 1; const im = t.image; if (im && im.width)
+            u.uImageAspect.value = im.width / im.height; });
+    };
+    const apply = (cfg) => {
+        applyConfig(u, cfg);
+        if (cfg.frameColor !== undefined)
+            fixU.uPaint.value.set(cfg.frameColor);
+        if (cfg.imageUrl !== undefined && (img === null || cfg.imageUrl !== (img.__url || ''))) {
+            setImage(cfg);
+            if (img)
+                img.__url = cfg.imageUrl;
+        }
+        if (lamp && cfg.glow !== undefined)
+            setLamps([lamp], undefined, 0.5 * cfg.glow);
+    };
+    rebuild(c);
+    apply(c);
+    const lastWorld = new THREE.Matrix4();
+    return {
+        object: group,
+        materials: [panelMat, fixture],
+        uniformSets: [u, fixU],
+        apply,
+        rebuild(cfg) { rebuild(cfg); apply(cfg); },
+        bounds() { const b = new THREE.Box3(); for (const m of [panel, frame])
+            if (m) {
+                m.updateMatrix();
+                if (!m.geometry.boundingBox)
+                    m.geometry.computeBoundingBox();
+                b.union(m.geometry.boundingBox.clone().applyMatrix4(m.matrix));
+            } return b; },
+        update() {
+            group.updateMatrixWorld();
+            if (lamp && !lastWorld.equals(group.matrixWorld)) {
+                lastWorld.copy(group.matrixWorld);
+                placeLamps([lamp], [headLocal], group.matrixWorld);
+                touchLamps();
+            }
+        },
+        dispose() { clear(); panelMat.dispose(); fixture.dispose(); },
+    };
+}