@3driseai/3drise-viewer 0.1.42 → 0.1.43

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

@@ -0,0 +1,67 @@
+import * as THREE from 'three';
+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;
+    };
+} & {
+    uPavColor: {
+        value: THREE.Color;
+    };
+    uPavRoughness: {
+        value: number;
+    };
+    uGrassMix: {
+        value: number;
+    };
+};
+export declare function applyConfig(u: any, c: any): void;
+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=park.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"park.d.ts","sourceRoot":"","sources":["../../../../src/components/urban/core/park.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAQ/B,eAAO,MAAM,QAAQ,UAA2B,CAAC;AAEjD,eAAO,MAAM,UAAU,UAA+H,CAAC;AAIvJ,wBAAgB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAqC;AACnE,wBAAgB,WAAW,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA,QAE/B;AAQD,wBAAgB,KAAK,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA;;;;;;;;;EA0GzB"}

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

@@ -0,0 +1,176 @@
+// Emitted from Claude outputs/urban-lab/park.mjs by emit_object.mjs — edit the lab module and re-emit.
+// =============================================================================
+// urban/park — a lawn inside a polygon with a looping path, a kerb and park lamps
+// =============================================================================
+// Construction. The outline (points, curve — the plaza's polygon) is one lawn slab in the
+// paving material's lawn mode (two greens broken by cells, no texture), with the plaza's
+// kerb around it. A PATH loops inside it: the outline shrunk toward its centre by
+// `pathInset`, sampled closed and drawn as a ribbon `pathWidth` wide in a library paving
+// set, with an optional cross path through the middle. Short park lamps stand along the
+// loop every lampSpacing and register in the lamp list, so the lawn and the path light up
+// at night with no real light. Trees, bushes and flowers are the vegetation family's
+// (scatter them with a layout over the park's outline); benches are street furniture.
+import * as THREE from 'three';
+import { createPavingUniforms, createPavingMaterial, applyTextureSet, loadTextureSet, buildLampGeometry, createFixtureUniforms, createFixtureMaterial, registerLamp, unregisterLamp, touchLamps, setLamps, placeLamps, samplePath, ribbon, mergeGeometries, } from '../urbanCore.js';
+import { slabGeometry, signedArea } from './plaza.js';
+export const LIGHTING = ['auto', 'day', 'night'];
+export const STRUCTURAL = ['points', 'curve', 'kerb', 'kerbHeight', 'pathInset', 'pathWidth', 'crossPath', 'pathTexture', 'lampSpacing', 'lampHeight'];
+// The lawn and the path are both the family's paving material (lawn mode / a paving set), so
+// the park has no shader of its own: createUniforms returns the lawn's uniforms.
+export function createUniforms() { return createPavingUniforms(); }
+export function applyConfig(u, c) {
+    if (c.lawnColor !== undefined)
+        u.uPavColor.value.set(c.lawnColor);
+}
+/** The outline shrunk toward its centroid by `inset` (0..0.9). */
+function insetPolygon(pts, inset) {
+    let cx = 0, cz = 0;
+    for (const [x, z] of pts) {
+        cx += x;
+        cz += z;
+    }
+    cx /= pts.length;
+    cz /= pts.length;
+    return pts.map(([x, z]) => [cx + (x - cx) * (1 - inset), cz + (z - cz) * (1 - inset)]);
+}
+export function build(u, c) {
+    const group = new THREE.Group();
+    const lawn = createPavingMaterial(u);
+    u.uGrassMix.value = 1;
+    const pathU = createPavingUniforms();
+    const pathMat = createPavingMaterial(pathU);
+    // The path lies on the lawn (two of the family's surfaces a few cm apart): a stronger depth
+    // offset than the lawn's, so it wins the depth test and never flickers as the camera moves.
+    pathMat.polygonOffsetFactor = -4;
+    pathMat.polygonOffsetUnits = -8;
+    const kerbU = createPavingUniforms();
+    const kerbMat = createPavingMaterial(kerbU);
+    const fixU = createFixtureUniforms();
+    const fixture = createFixtureMaterial(fixU);
+    const meshes = [];
+    let lamps = [], lampLocal = [];
+    const state = { pathTex: null };
+    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 add = (mesh) => { mesh.frustumCulled = false; group.add(mesh); meshes.push(mesh); };
+    const rebuild = (cfg) => {
+        clear();
+        let pts = (cfg.points || []).filter((p) => Array.isArray(p) && p.length >= 2);
+        if (pts.length < 3)
+            return;
+        if (signedArea(pts) > 0)
+            pts = [...pts].reverse();
+        const outline = samplePath(pts, cfg.curve, true);
+        if (outline.length < 3)
+            return;
+        const kh = cfg.kerb ? Math.max(0.02, cfg.kerbHeight) : 0.02;
+        add(new THREE.Mesh(slabGeometry(outline, kh), lawn));
+        if (cfg.kerb) {
+            add(new THREE.Mesh(mergeGeometries([ribbon(outline, -0.3, 0, kh, kh, false), ribbon(outline, 0, 0, kh, 0.0, true, 1)], [['aUV', 2]]), kerbMat));
+        }
+        // The path loop (and the cross path), 2 cm above the lawn.
+        const loop = samplePath(insetPolygon(pts, Math.min(0.9, Math.max(0.05, cfg.pathInset))), cfg.curve, true);
+        const pw = cfg.pathWidth;
+        const parts = [ribbon(loop, -pw / 2, pw / 2, kh + 0.04, kh + 0.04, false)];
+        if (cfg.crossPath) {
+            // Across the loop: the two loop points farthest apart, joined by a straight path.
+            let a = 0, b = 0, best = 0;
+            for (let i = 0; i < loop.length; i += 3)
+                for (let j = i + 3; j < loop.length; j += 3) {
+                    const d = loop[i].p.distanceToSquared(loop[j].p);
+                    if (d > best) {
+                        best = d;
+                        a = i;
+                        b = j;
+                    }
+                }
+            const cross = samplePath([[loop[a].p.x, loop[a].p.z], [loop[b].p.x, loop[b].p.z]], 0, false);
+            if (cross.length >= 2)
+                parts.push(ribbon(cross, -pw / 2, pw / 2, kh + 0.04, kh + 0.04, false));
+        }
+        add(new THREE.Mesh(mergeGeometries(parts, [['aUV', 2]]), pathMat));
+        // Lamps along the loop, on its outer edge, every lampSpacing metres.
+        const L = loop[loop.length - 1].s;
+        const n = Math.max(1, Math.round(L / cfg.lampSpacing));
+        const geo = buildLampGeometry({ height: cfg.lampHeight, armReach: 0.5, headWidth: 0.5, headDepth: 0.5 });
+        const lm = new THREE.InstancedMesh(geo, fixture, n);
+        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 < n; i++) {
+            const s = (i + 0.5) * L / n;
+            let k = 0;
+            while (k < loop.length - 1 && loop[k + 1].s < s)
+                k++;
+            const S = loop[k];
+            p.copy(S.p).addScaledVector(S.n, pw / 2 + 0.6);
+            q.setFromAxisAngle(up, Math.atan2(S.n.x, S.n.z) + Math.PI);
+            m.compose(p, q, sc);
+            lm.setMatrixAt(i, m);
+            const head = geo.userData.head.clone().applyMatrix4(m);
+            lampLocal.push(head);
+            lamps.push(registerLamp({ id: 'park-' + i, position: head.clone(), color: new THREE.Color(cfg.lampColor), radius: cfg.lampRadius, intensity: cfg.lampIntensity, on: true }));
+        }
+        lm.instanceMatrix.needsUpdate = true;
+        add(lm);
+    };
+    const setTextures = (cfg) => {
+        const pm = cfg.pathTexture && cfg.pathTexture.maps;
+        state.pathTex = pm && pm.color ? loadTextureSet(pm) : null;
+        const ap = () => {
+            const t = state.pathTex && state.pathTex.color ? state.pathTex : null;
+            applyTextureSet(pathU, 'uPav', t, cfg.pathTexture && cfg.pathTexture.tileSize, 0.7);
+            applyTextureSet(kerbU, 'uPav', t, cfg.pathTexture && cfg.pathTexture.tileSize, 0.7);
+        };
+        if (state.pathTex)
+            state.pathTex.ready.then(ap);
+        ap();
+    };
+    const apply = (cfg) => {
+        applyConfig(u, cfg);
+        if (cfg.pathColor !== undefined)
+            pathU.uPavColor.value.set(cfg.pathColor);
+        if (cfg.kerbColor !== undefined)
+            kerbU.uPavColor.value.set(cfg.kerbColor);
+        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: [lawn, pathMat, kerbMat, fixture],
+        uniformSets: [u, pathU, kerbU, fixU],
+        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() {
+            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(); lawn.dispose(); pathMat.dispose(); kerbMat.dispose(); fixture.dispose(); },
+    };
+}

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

@@ -0,0 +1,82 @@
+import * as THREE from 'three';
+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;
+    };
+} & {
+    uAsphaltColor: {
+        value: THREE.Color;
+    };
+    uMarkingColor: {
+        value: THREE.Color;
+    };
+    uSize: {
+        value: THREE.Vector2;
+    };
+    uBay: {
+        value: THREE.Vector2;
+    };
+    uAisle: {
+        value: number;
+    };
+    uWear: {
+        value: number;
+    };
+    uSeed: {
+        value: number;
+    };
+};
+export declare function applyConfig(u: any, c: any, tex?: any): void;
+export declare const VERT = "\nattribute vec2 aUV;\nvarying vec3 vN; varying vec3 vP; varying vec2 vQ;\n#include <fog_pars_vertex>\nvoid main() {\n    vec4 wp = modelMatrix * vec4(position, 1.0);\n    vP = wp.xyz;\n    vN = normalize(mat3(modelMatrix) * normal);\n    vQ = aUV;\n    vec4 mvPosition = viewMatrix * wp;\n    gl_Position = projectionMatrix * mvPosition;\n    #include <fog_vertex>\n}";
+export declare const FRAG: string;
+export declare function createMaterial(u: 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=parkingLot.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parkingLot.d.ts","sourceRoot":"","sources":["../../../../src/components/urban/core/parkingLot.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAS/B,eAAO,MAAM,QAAQ,UAA2B,CAAC;AAEjD,eAAO,MAAM,UAAU,UAA+J,CAAC;AAGvL,wBAAgB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAU7B;AAED,wBAAgB,WAAW,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA,EAAE,GAAG,MAAY,QAShD;AAED,eAAO,MAAM,IAAI,qXAYf,CAAC;AAEH,eAAO,MAAM,IAAI,QAkDf,CAAC;AAEH,wBAAgB,cAAc,CAAC,CAAC,KAAA,wBAE/B;AAKD,wBAAgB,KAAK,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA;;;;;;;;;EAoIzB"}

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

@@ -0,0 +1,284 @@
+// Emitted from Claude outputs/urban-lab/parkingLot.mjs by emit_object.mjs — edit the lab module and re-emit.
+// =============================================================================
+// urban/parkingLot — a surface car park: marked bays, aisles, tall lamps, parked cars
+// =============================================================================
+// Construction. ONE asphalt slab (width x depth, UVs in metres) whose fragment shader draws
+// the bays: modules along z of two bay rows (bayDepth each) around an aisle, bay lines every
+// bayWidth along x, a kerb line around, with the road family's wear and tone variation; a
+// kerb ribbon around the slab in the paving material. Lamps (one tall fixture geometry,
+// instanced) stand in the aisle centre lines every lampSpacing and register in the lamp
+// list, so the asphalt and the cars light up at night with no real light. Cars are ONE
+// InstancedMesh of a low-poly car (body + cabin + wheels, ~80 triangles) in the fixture
+// material with per-instance paint (instanceColor) from a palette; `cars` is the occupancy.
+// A low-poly car MODEL from the library is still the better hero car; these are the crowd.
+import * as THREE from 'three';
+import { mulberry32, 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, ribbon, SURFACE_DEPTH, buildCarGeometry, CAR_PALETTE, } from '../urbanCore.js';
+export const LIGHTING = ['auto', 'day', 'night'];
+export const STRUCTURAL = ['width', 'depth', 'bayWidth', 'bayDepth', 'aisle', 'texture', 'kerb', 'kerbHeight', 'kerbTexture', 'lampSpacing', 'lampHeight', 'cars', 'carScale', 'seed'];
+// ---------------------------------------------------------------------------- asphalt material
+export function createUniforms() {
+    return Object.assign(createSunUniforms(), createLampUniforms(), createTextureUniforms('uAsp'), {
+        uAsphaltColor: { value: new THREE.Color() },
+        uMarkingColor: { value: new THREE.Color() },
+        uSize: { value: new THREE.Vector2(60, 44) },
+        uBay: { value: new THREE.Vector2(2.5, 5) },
+        uAisle: { value: 6.5 },
+        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.width !== undefined && c.depth !== undefined)
+        u.uSize.value.set(c.width, c.depth);
+    if (c.bayWidth !== undefined && c.bayDepth !== undefined)
+        u.uBay.value.set(c.bayWidth, c.bayDepth);
+    if (c.aisle !== undefined)
+        u.uAisle.value = c.aisle;
+    if (c.wear !== undefined)
+        u.uWear.value = c.wear;
+    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 vQ;
+${GLSL_FOG_VERT_PARS}
+void main() {
+    vec4 wp = modelMatrix * vec4(position, 1.0);
+    vP = wp.xyz;
+    vN = normalize(mat3(modelMatrix) * normal);
+    vQ = 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 vec2 uSize; uniform vec2 uBay; uniform float uAisle; uniform float uWear; uniform float uSeed;
+varying vec3 vN; varying vec3 vP; varying vec2 vQ;
+${GLSL_FOG_PARS}
+
+float lineAA(float x, float w) { return 1.0 - bandAA(abs(x), w * 0.5, 1e9); }
+
+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 x = vQ.x, z = vQ.y;
+    vec2 hs = uSize * 0.5;
+    // Modules along z: [bay row][aisle][bay row], starting at the -z edge after a 1 m margin.
+    float modH = uBay.y * 2.0 + uAisle;
+    float zz = z + hs.y - 1.0;
+    float mi = floor(zz / modH), mz = zz - mi * modH;
+    float nMods = floor((uSize.y - 2.0) / modH);
+    bool inMod = zz >= 0.0 && mi < nMods;
+    float lw = 0.12;
+    float mark = 0.0;
+    if (inMod) {
+        // In a bay row (not the aisle): bay lines every bayWidth, and the row's inner edge line.
+        float inRowA = step(mz, uBay.y), inRowB = step(uBay.y + uAisle, mz);
+        float inRow = max(inRowA, inRowB);
+        float xx = x + hs.x - 1.0;
+        float nBays = floor((uSize.x - 2.0) / uBay.x);
+        float bx = mod(xx, uBay.x);
+        float bayLine = max(lineAA(bx, lw), lineAA(bx - uBay.x, lw)) * step(0.0, xx) * step(xx, nBays * uBay.x);
+        float edgeLine = max(lineAA(mz - uBay.y, lw), lineAA(mz - uBay.y - uAisle, lw)) * step(0.0, xx) * step(xx, nBays * uBay.x);
+        mark = max(bayLine * inRow, edgeLine);
+    }
+    // Perimeter line 0.6 m in from the kerb.
+    mark = max(mark, max(lineAA(abs(x) - (hs.x - 0.6), lw), lineAA(abs(z) - (hs.y - 0.6), lw)));
+    float macro = 0.92 + 0.16 * vnoise21(vQ / 9.0 + uSeed);
+    vec3 albedo = uAsphaltColor * mul * macro;
+    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.5 * step(chip, 0.3 * uWear), 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 });
+}
+// The car (buildCarGeometry, CAR_PALETTE) is the family's shared crowd car: common.mjs.
+// ---------------------------------------------------------------------------- lab build
+export function build(u, c) {
+    const group = new THREE.Group();
+    const asphalt = createMaterial(u);
+    const pavU = createPavingUniforms();
+    const paving = createPavingMaterial(pavU);
+    const fixU = createFixtureUniforms();
+    const fixture = createFixtureMaterial(fixU);
+    const carU = createFixtureUniforms();
+    const carMat = createFixtureMaterial(carU);
+    carU.uPaint.value.set('#ffffff');
+    carU.uAccent.value.set('#15171a');
+    carU.uRough.value = 0.35;
+    const meshes = [];
+    let lamps = [], lampLocal = [];
+    const state = { tex: null, kerbTex: null };
+    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 rebuild = (cfg) => {
+        clear();
+        const rng = mulberry32(cfg.seed * 331 + 7);
+        const W = cfg.width, D = cfg.depth, hw = W / 2, hd = D / 2;
+        // Slab with UVs in metres.
+        const g = new THREE.PlaneGeometry(W, D, 1, 1);
+        g.rotateX(-Math.PI / 2);
+        g.setAttribute('aUV', new THREE.BufferAttribute(new Float32Array([-hw, -hd, hw, -hd, -hw, hd, hw, hd]), 2));
+        const slab = new THREE.Mesh(g, asphalt);
+        slab.position.y = 0.02;
+        slab.frustumCulled = false;
+        group.add(slab);
+        meshes.push(slab);
+        // Kerb: a ribbon around the rectangle, in the paving material.
+        if (cfg.kerb) {
+            const kh = Math.max(0.02, cfg.kerbHeight);
+            const corners = [[-hw, -hd], [hw, -hd], [hw, hd], [-hw, hd], [-hw, -hd]];
+            const samples = corners.map(([x, z], i) => {
+                const q = corners[Math.min(i + 1, 4)], p0 = corners[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 * 10 };
+            });
+            const parts = [ribbon(samples, 0, 0.4, kh, kh, false), ribbon(samples, 0, 0, kh, 0.0, true, -1), ribbon(samples, 0.4, 0.4, 0.0, kh, true, 1)];
+            const kerb = new THREE.Mesh(mergeGeometries(parts, [['aUV', 2]]), paving);
+            kerb.frustumCulled = false;
+            group.add(kerb);
+            meshes.push(kerb);
+        }
+        // Bay centres: modules along z, bays along x (the same layout the shader draws).
+        const modH = cfg.bayDepth * 2 + cfg.aisle;
+        const nMods = Math.floor((D - 2) / modH), nBays = Math.floor((W - 2) / cfg.bayWidth);
+        const bays = [], aisles = [];
+        for (let m = 0; m < nMods; m++) {
+            const z0 = -hd + 1 + m * modH;
+            aisles.push(z0 + cfg.bayDepth + cfg.aisle / 2);
+            for (let b = 0; b < nBays; b++) {
+                const x = -hw + 1 + (b + 0.5) * cfg.bayWidth;
+                bays.push({ x, z: z0 + cfg.bayDepth / 2, face: 1 }); // row A, nose toward -z
+                bays.push({ x, z: z0 + cfg.bayDepth + cfg.aisle + cfg.bayDepth / 2, face: -1 }); // row B
+            }
+        }
+        // Lamps along the aisle centre lines.
+        const where = [];
+        for (const za of aisles) {
+            const n = Math.max(1, Math.round((W - 4) / cfg.lampSpacing));
+            for (let i = 0; i < n; i++)
+                where.push({ x: -hw + 2 + (i + 0.5) * (W - 4) / n, z: za });
+        }
+        if (where.length) {
+            const geo = buildLampGeometry({ height: cfg.lampHeight, armReach: 0.9, headWidth: 1.2, headDepth: 0.5 });
+            const lm = 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);
+            where.forEach((w, i) => {
+                p.set(w.x, 0, w.z);
+                q.setFromAxisAngle(up, Math.PI / 2);
+                m.compose(p, q, sc);
+                lm.setMatrixAt(i, m);
+                const head = geo.userData.head.clone().applyMatrix4(m);
+                lampLocal.push(head);
+                lamps.push(registerLamp({ id: 'lot-' + 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);
+        }
+        // Cars: a share of the bays, palette paint, a little slop in the bay.
+        const occupied = bays.filter(() => rng() < cfg.cars);
+        if (occupied.length) {
+            const geo = buildCarGeometry();
+            const cm = new THREE.InstancedMesh(geo, carMat, occupied.length);
+            const m = new THREE.Matrix4(), q = new THREE.Quaternion(), p = new THREE.Vector3(), sc = new THREE.Vector3(), up = new THREE.Vector3(0, 1, 0), col = new THREE.Color();
+            occupied.forEach((b, i) => {
+                const s = cfg.carScale * (0.92 + rng() * 0.16);
+                p.set(b.x + (rng() - 0.5) * 0.3, 0, b.z + (rng() - 0.5) * 0.4);
+                q.setFromAxisAngle(up, b.face * Math.PI / 2 + (rng() - 0.5) * 0.08);
+                sc.set(s, s, s);
+                m.compose(p, q, sc);
+                cm.setMatrixAt(i, m);
+                col.set(CAR_PALETTE[Math.floor(rng() * CAR_PALETTE.length)]);
+                cm.setColorAt(i, col);
+            });
+            cm.instanceMatrix.needsUpdate = true;
+            cm.instanceColor.needsUpdate = true;
+            cm.frustumCulled = false;
+            cm.castShadow = true;
+            group.add(cm);
+            meshes.push(cm);
+        }
+    };
+    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 km = cfg.kerbTexture && cfg.kerbTexture.maps;
+        state.kerbTex = km && km.color ? loadTextureSet(km) : null;
+        const ap = () => applyTextureSet(pavU, 'uPav', state.kerbTex && state.kerbTex.color ? state.kerbTex : null, cfg.kerbTexture && cfg.kerbTexture.tileSize, 0.7);
+        if (state.kerbTex)
+            state.kerbTex.ready.then(ap);
+        ap();
+    };
+    const apply = (cfg) => {
+        applyConfig(u, cfg, undefined);
+        if (cfg.kerbColor !== undefined)
+            pavU.uPavColor.value.set(cfg.kerbColor);
+        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, fixture, carMat],
+        uniformSets: [u, pavU, fixU, carU],
+        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() {
+            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(); fixture.dispose(); carMat.dispose(); },
+    };
+}

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

@@ -0,0 +1,24 @@
+import * as THREE from 'three';
+export declare const PATTERNS: string[];
+export declare const LIGHTING: string[];
+export declare const STRUCTURAL: string[];
+export declare function createUniforms(): any;
+export declare function applyConfig(u: any, c: any, tex?: any, bandTex?: any): void;
+export declare const VERT = "\nattribute vec2 aUV;\nvarying vec3 vN; varying vec3 vP; varying vec2 vUVm;\n#include <fog_pars_vertex>\nvoid main() {\n    vec4 wp = modelMatrix * vec4(position, 1.0);\n    vP = wp.xyz;\n    vN = normalize(mat3(modelMatrix) * normal);\n    vUVm = aUV;\n    vec4 mvPosition = viewMatrix * wp;\n    gl_Position = projectionMatrix * mvPosition;\n    #include <fog_vertex>\n}";
+export declare const FRAG: string;
+export declare function createMaterial(u: any): THREE.ShaderMaterial;
+/** Signed area of an [x, z] polygon (positive = counter-clockwise seen from above, +y). */
+export declare function signedArea(pts: any): number;
+/** The slab: the sampled outline as a Shape, triangulated, UVs in metres, laid flat at height y. */
+export declare function slabGeometry(samples: any, y: any): THREE.ShapeGeometry;
+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=plaza.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"plaza.d.ts","sourceRoot":"","sources":["../../../../src/components/urban/core/plaza.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAO/B,eAAO,MAAM,QAAQ,UAAkD,CAAC;AACxE,eAAO,MAAM,QAAQ,UAA2B,CAAC;AAEjD,eAAO,MAAM,UAAU,UAA8E,CAAC;AAGtG,wBAAgB,cAAc,QAU7B;AAED,wBAAgB,WAAW,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA,EAAE,GAAG,MAAY,EAAE,OAAO,MAAY,QAUrE;AAED,eAAO,MAAM,IAAI,yXAYf,CAAC;AAEH,eAAO,MAAM,IAAI,QAiDf,CAAC;AAEH,wBAAgB,cAAc,CAAC,CAAC,KAAA,wBAE/B;AAGD,2FAA2F;AAC3F,wBAAgB,UAAU,CAAC,GAAG,KAAA,UAI7B;AAED,oGAAoG;AACpG,wBAAgB,YAAY,CAAC,OAAO,KAAA,EAAE,CAAC,KAAA,uBAqBtC;AAGD,wBAAgB,KAAK,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA;;;;;;;;;EA8DzB"}