@3driseai/3drise-viewer 0.1.42 → 0.1.44

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

@@ -0,0 +1,119 @@
+import * as THREE from 'three';
+import { applyConfig as applyBuilding } from './building';
+export declare const PLOTS: string[];
+export declare const STREETS: string[];
+export declare const STRUCTURAL: string[];
+/** Width of a block street with its pavements (the corridor it needs). */
+export declare function blockStreetWidth(c: any): number;
+/**
+ * The block's buildings as an instance list, its XZ extent, and where its streets run: laneX is
+ * the x of a street running along z (between the centre columns), laneZ the z of one along x.
+ * The gap at a street widens just enough for it (1 m clear each side); every building keeps the
+ * size and seed-drawn look it has without streets.
+ */
+export declare function blockInstances(c: any): {
+    list: any[];
+    ext: {
+        w: number;
+        d: number;
+    };
+    laneX: number;
+    laneZ: number;
+    streetWidth: number;
+};
+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;
+    };
+} & {
+    uWallColor: {
+        value: THREE.Color;
+    };
+    uGlassColor: {
+        value: THREE.Color;
+    };
+    uGlassReflect: {
+        value: number;
+    };
+    uMullionColor: {
+        value: THREE.Color;
+    };
+    uRoofColor: {
+        value: THREE.Color;
+    };
+    uMullionWidth: {
+        value: number;
+    };
+    uLobby: {
+        value: number;
+    };
+    uLightColor: {
+        value: THREE.Color;
+    };
+    uCoolLightColor: {
+        value: THREE.Color;
+    };
+    uLightWarmth: {
+        value: number;
+    };
+    uWindowGlow: {
+        value: number;
+    };
+    uFlicker: {
+        value: number;
+    };
+    uTime: {
+        value: number;
+    };
+};
+export { applyBuilding as applyConfig };
+export declare function build(u: any, c: any): {
+    object: THREE.Group<THREE.Object3DEventMap>;
+    readonly materials: THREE.ShaderMaterial[];
+    readonly uniformSets: any[];
+    /** Facades and plot gather the nearest lamps (their own streets' too); the merged streets use the baked field. */
+    lampTargets(): any[];
+    apply: (cfg: any) => void;
+    rebuild(cfg: any): void;
+    bounds(): any;
+    update(dt: any, camera: any): void;
+    dispose(): void;
+};
+//# sourceMappingURL=block.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"block.d.ts","sourceRoot":"","sources":["../../../../src/components/urban/core/block.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAI/B,OAAO,EAAsI,WAAW,IAAI,aAAa,EAAoC,MAAM,YAAY,CAAC;AAEhO,eAAO,MAAM,KAAK,UAA4B,CAAC;AAC/C,eAAO,MAAM,OAAO,UAAwC,CAAC;AAE7D,eAAO,MAAM,UAAU,UACoH,CAAC;AAE5I,0EAA0E;AAC1E,wBAAgB,gBAAgB,CAAC,CAAC,KAAA,UAEjC;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,CAAC,KAAA;;;;;;;;;EAuC/B;AAiCD,wBAAgB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAiC;AAC/D,OAAO,EAAE,aAAa,IAAI,WAAW,EAAE,CAAC;AAExC,wBAAgB,KAAK,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA;;;;IAiGlB,kHAAkH;;;;;;;EAkBzH"}

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

@@ -0,0 +1,266 @@
+// Emitted from Claude outputs/urban-lab/block.mjs by emit_object.mjs — edit the lab module and re-emit.
+// =============================================================================
+// urban/block — a grid of buildings with jittered sizes, heights and facades, on a plot
+// =============================================================================
+// A layout preset over `building`: columns x rows cells of (width + gap) x (depth + gap);
+// in each cell a building whose footprint, floors (floorsMin..floorsMax), facade kind,
+// wall tint and roof are drawn from the block's seed, `facadeMix` deciding how much they
+// may differ from the block's own building knobs. Every building's volumes go into ONE
+// InstancedMesh with the facade material (building.mjs) — a block of 20 buildings is one
+// draw call — and a plot (paving or lawn) sits under them, lit by the lamp list.
+//
+// Streets: the block can run its own small streets through the middle — between the two centre
+// columns, the two centre rows, or both (a cross with a junction). They are the real road and
+// junction cores at a smaller size (lanes, markings, kerbs, pavements, lamps), merged by
+// material like a street grid and lit by a baked lamp field; the middle gap widens to fit them
+// and the plot leaves their corridor out. Their lamps also light the plot and the facades.
+import * as THREE from 'three';
+import { mulberry32, createPavingUniforms, createPavingMaterial, applyTextureSet, loadTextureSet, mergeByMaterial, createLampField } from '../urbanCore.js';
+import * as ROAD from './road.js';
+import * as JUNCTION from './junction.js';
+import { FOOTPRINTS, FACADES, ROOFS, pickMix, addBuilding, buildInstancedBoxes, disposeInstanced, createUniforms as buildingUniforms, applyConfig as applyBuilding, createMaterial as facadeMaterial } from './building.js';
+export const PLOTS = ['paved', 'lawn', 'none'];
+export const STREETS = ['none', 'cross', 'alongX', 'alongZ']; // alongX: a street running along x (between the centre rows)
+export const STRUCTURAL = ['mix', 'footprint', 'width', 'depth', 'floorHeight', 'lobby', 'roof', 'seed', 'texture', 'columns', 'rows', 'gap', 'sizeJitter', 'floorsMin', 'floorsMax', 'facadeMix', 'plot', 'plotMargin', 'plotTexture', 'facade', 'windowRatio', 'bayWidth', 'windowLights',
+    'streets', 'streetLanes', 'streetLaneWidth', 'streetSidewalk', 'streetTexture', 'streetLamps', 'streetLampSpacing', 'streetLampHeight'];
+/** Width of a block street with its pavements (the corridor it needs). */
+export function blockStreetWidth(c) {
+    return Math.max(1, Math.round(c.streetLanes ?? 2)) * (c.streetLaneWidth ?? 3) + 2 * Math.max(0, c.streetSidewalk ?? 2);
+}
+/**
+ * The block's buildings as an instance list, its XZ extent, and where its streets run: laneX is
+ * the x of a street running along z (between the centre columns), laneZ the z of one along x.
+ * The gap at a street widens just enough for it (1 m clear each side); every building keeps the
+ * size and seed-drawn look it has without streets.
+ */
+export function blockInstances(c) {
+    const rng = mulberry32(c.seed * 7919 + 3);
+    const list = [];
+    const cols = Math.max(1, Math.round(c.columns)), rows = Math.max(1, Math.round(c.rows));
+    const cellW = c.width + c.gap, cellD = c.depth + c.gap;
+    const streets = c.streets || 'none', sw = blockStreetWidth(c);
+    const wantX = (streets === 'cross' || streets === 'alongZ') && cols >= 2, wantZ = (streets === 'cross' || streets === 'alongX') && rows >= 2;
+    const kx = Math.floor(cols / 2), kz = Math.floor(rows / 2);
+    const ex = wantX ? Math.max(0, sw + 2 - c.gap) : 0, ez = wantZ ? Math.max(0, sw + 2 - c.gap) : 0;
+    const x0 = -((cols - 1) * cellW + ex) / 2, z0 = -((rows - 1) * cellD + ez) / 2;
+    const colX = (col) => x0 + col * cellW + (wantX && col >= kx ? ex : 0);
+    const rowZ = (r) => z0 + r * cellD + (wantZ && r >= kz ? ez : 0);
+    const base = new THREE.Color(c.wallColor);
+    const hsl = { h: 0, s: 0, l: 0 };
+    base.getHSL(hsl);
+    const tmp = new THREE.Color();
+    for (let r = 0; r < rows; r++)
+        for (let col = 0; col < cols; col++) {
+            const j = c.sizeJitter;
+            const w = c.width * (1 - j * rng() * 0.9), d = c.depth * (1 - j * rng() * 0.9);
+            const mix = c.facadeMix;
+            const floorsOwn = Math.round(c.floorsMin + (c.floorsMax - c.floorsMin) * Math.pow(rng(), 1.4));
+            // A city mix picks footprint, facade, roof, floors and lobby per building; 'custom' varies the block's own knobs.
+            const pick = pickMix(rng, c.mix);
+            const footprint = pick ? pick.footprint : (rng() < mix * 0.6 ? FOOTPRINTS[Math.floor(rng() * FOOTPRINTS.length)] : c.footprint);
+            const facade = pick ? pick.facade : (rng() < mix * 0.8 ? FACADES[Math.floor(rng() * FACADES.length)] : c.facade);
+            const roof = pick ? pick.roof : (rng() < mix * 0.5 ? ROOFS[Math.floor(rng() * ROOFS.length)] : c.roof);
+            const windowRatio = Math.min(0.95, Math.max(0.15, c.windowRatio + (rng() - 0.5) * 0.3 * mix));
+            const lights = Math.min(1, Math.max(0, c.windowLights + (rng() - 0.5) * 0.4 * mix));
+            // Tint: a hue nudge and a lightness spread around the wall colour, as a per-channel multiplier.
+            tmp.setHSL((hsl.h + (rng() - 0.5) * 0.08 * mix + 1) % 1, Math.min(1, hsl.s * (1 + (rng() - 0.5) * 0.6 * mix)), Math.min(0.95, Math.max(0.08, hsl.l * (1 + (rng() - 0.5) * 0.7 * mix))));
+            const tint = [tmp.r / Math.max(base.r, 0.02), tmp.g / Math.max(base.g, 0.02), tmp.b / Math.max(base.b, 0.02)].map((v) => Math.min(2.2, Math.max(0.35, v)));
+            const floors = pick ? pick.floors : floorsOwn;
+            const b = Object.assign({}, c, { width: w, depth: d, floors, footprint, facade, roof, windowRatio, windowLights: lights, lobby: pick ? pick.lobby : c.lobby });
+            // Within the cell, slide the building off-centre a little so the rows do not read as a ruler.
+            const ox = (rng() - 0.5) * (cellW - w - 2) * 0.5 * j, oz = (rng() - 0.5) * (cellD - d - 2) * 0.5 * j;
+            addBuilding(list, b, colX(col) + ox, rowZ(r) + oz, 0, tint, Math.floor(rng() * 1e6));
+        }
+    const ext = { w: cols * cellW + ex + 2 * c.plotMargin, d: rows * cellD + ez + 2 * c.plotMargin };
+    const laneX = wantX ? (colX(kx - 1) + colX(kx)) / 2 : null, laneZ = wantZ ? (rowZ(kz - 1) + rowZ(kz)) / 2 : null;
+    return { list, ext, laneX, laneZ, streetWidth: sw };
+}
+/** Rectangles [x0, z0, x1, z1] covering the plot minus the street corridors. */
+function plotPieces(ext, laneX, laneZ, sw) {
+    const xs = laneX === null ? [[-ext.w / 2, ext.w / 2]] : [[-ext.w / 2, laneX - sw / 2], [laneX + sw / 2, ext.w / 2]];
+    const zs = laneZ === null ? [[-ext.d / 2, ext.d / 2]] : [[-ext.d / 2, laneZ - sw / 2], [laneZ + sw / 2, ext.d / 2]];
+    const out = [];
+    for (const [a, b] of xs)
+        for (const [c, d] of zs)
+            if (b - a > 0.1 && d - c > 0.1)
+                out.push([a, c, b, d]);
+    return out;
+}
+// The road / junction knobs of a block street (every knob the cores read; the repo cores have no defaults table).
+function streetRoadCfg(c, points) {
+    return {
+        type: 'road', enabled: true, points, curve: 0, lanes: Math.max(1, Math.round(c.streetLanes)), laneWidth: c.streetLaneWidth,
+        markings: 'dashed', laneLines: true, edgeLines: true, crosswalks: false, lampSide: 'alternate',
+        markingColor: c.streetMarkingColor, asphaltColor: c.streetAsphaltColor, wear: 0.4, texture: c.streetTexture,
+        sidewalk: c.streetSidewalk, kerbHeight: 0.15, sidewalkColor: c.plotColor || '#9d9892', sidewalkTexture: c.plotTexture,
+        lampSpacing: c.streetLamps ? c.streetLampSpacing : 0, lampHeight: c.streetLampHeight, lampPaint: '#2b2f33', lampColor: c.streetLampColor, lampRadius: c.streetLampRadius, lampIntensity: c.streetLampIntensity,
+        lighting: c.lighting, seed: c.seed,
+    };
+}
+function streetJunctionCfg(c) {
+    return {
+        type: 'junction', enabled: true, shape: 'cross', islandRadius: 10, signalHeight: 4.5, lanes: Math.max(1, Math.round(c.streetLanes)), laneWidth: c.streetLaneWidth, armLength: 6, cornerRadius: 3, crossings: true,
+        markingColor: c.streetMarkingColor, asphaltColor: c.streetAsphaltColor, wear: 0.4, texture: c.streetTexture,
+        sidewalk: c.streetSidewalk > 0.05, kerbHeight: 0.15, sidewalkColor: c.plotColor || '#9d9892', sidewalkTexture: c.plotTexture,
+        signals: false, signalCycle: 14, signalPaint: '#2b2f33',
+        lamps: c.streetLamps, lampHeight: c.streetLampHeight, lampPaint: '#2b2f33', lampColor: c.streetLampColor, lampRadius: c.streetLampRadius, lampIntensity: c.streetLampIntensity,
+        lighting: c.lighting, seed: c.seed,
+    };
+}
+export function createUniforms() { return buildingUniforms(); }
+export { applyBuilding as applyConfig };
+export function build(u, c) {
+    const group = new THREE.Group();
+    const mat = facadeMaterial(u);
+    const pavU = createPavingUniforms();
+    const paving = createPavingMaterial(pavU);
+    let mesh = null, plot = null;
+    const state = { tex: null, plotTex: null, ext: { w: 1, d: 1 } };
+    // The streets: road / junction instances (their objects stay in the group, empty, so their
+    // lamps follow the block's transform), drawn as merged meshes lit by one lamp field.
+    const uR = ROAD.createUniforms(), uJ = JUNCTION.createUniforms();
+    const field = createLampField();
+    let kids = [], merged = [];
+    const clearStreets = () => {
+        for (const m of merged) {
+            group.remove(m);
+            m.geometry.dispose();
+        }
+        merged = [];
+        for (const k of kids) {
+            group.remove(k.object);
+            k.dispose();
+        }
+        kids = [];
+    };
+    const rebuild = (cfg) => {
+        if (mesh) {
+            group.remove(mesh);
+            disposeInstanced(mesh);
+            mesh = null;
+        }
+        if (plot) {
+            group.remove(plot);
+            plot.geometry.dispose();
+            plot = null;
+        }
+        clearStreets();
+        const { list, ext, laneX, laneZ, streetWidth } = blockInstances(cfg);
+        state.ext = ext;
+        mesh = buildInstancedBoxes(list, mat);
+        group.add(mesh);
+        if (cfg.plot !== 'none') {
+            // The plot leaves the street corridors out (the streets' own pavements cover them; no overlap to flicker).
+            const pos = [], uv = [], idx = [];
+            for (const [x0, z0, x1, z1] of plotPieces(ext, laneX, laneZ, streetWidth)) {
+                const o = pos.length / 3;
+                pos.push(x0, 0, z0, x1, 0, z0, x0, 0, z1, x1, 0, z1);
+                uv.push(x0, z0, x1, z0, x0, z1, x1, z1);
+                idx.push(o, o + 2, o + 1, o + 1, o + 2, o + 3);
+            }
+            const g = new THREE.BufferGeometry();
+            g.setAttribute('position', new THREE.Float32BufferAttribute(pos, 3));
+            g.setAttribute('normal', new THREE.Float32BufferAttribute(pos.map((_, i) => (i % 3 === 1 ? 1 : 0)), 3));
+            g.setAttribute('aUV', new THREE.Float32BufferAttribute(uv, 2));
+            g.setIndex(idx);
+            plot = new THREE.Mesh(g, paving);
+            plot.position.y = 0.01;
+            group.add(plot);
+        }
+        pavU.uGrassMix.value = cfg.plot === 'lawn' ? 1 : 0;
+        // Streets from plot edge to plot edge; a junction where two cross.
+        if (laneX !== null || laneZ !== null) {
+            const halfW = ext.w / 2, halfD = ext.d / 2;
+            const jc = streetJunctionCfg(cfg), reach = JUNCTION.junctionReach(jc);
+            const roads = [];
+            if (laneX !== null && laneZ !== null) {
+                const j = JUNCTION.build(uJ, jc);
+                j.object.position.set(laneX, 0, laneZ);
+                group.add(j.object);
+                kids.push(j);
+                roads.push([[laneX, -halfD], [laneX, laneZ - reach]], [[laneX, laneZ + reach], [laneX, halfD]]);
+                roads.push([[-halfW, laneZ], [laneX - reach, laneZ]], [[laneX + reach, laneZ], [halfW, laneZ]]);
+            }
+            else if (laneX !== null)
+                roads.push([[laneX, -halfD], [laneX, halfD]]);
+            else
+                roads.push([[-halfW, laneZ], [halfW, laneZ]]);
+            for (const pts of roads) {
+                const len = Math.hypot(pts[1][0] - pts[0][0], pts[1][1] - pts[0][1]);
+                if (len < 2)
+                    continue;
+                const r = ROAD.build(uR, streetRoadCfg(cfg, pts));
+                group.add(r.object);
+                kids.push(r);
+            }
+            merged = mergeByMaterial(group, kids.map((k) => k.object), field);
+        }
+    };
+    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(() => applyBuilding(u, cfg, state.tex));
+        applyBuilding(u, cfg, state.tex && state.tex.color ? state.tex : null);
+        const pm = cfg.plotTexture && cfg.plotTexture.maps;
+        state.plotTex = pm && pm.color ? loadTextureSet(pm) : null;
+        const ap = () => applyTextureSet(pavU, 'uPav', state.plotTex && state.plotTex.color ? state.plotTex : null, cfg.plotTexture && cfg.plotTexture.tileSize, 0.7);
+        if (state.plotTex)
+            state.plotTex.ready.then(ap);
+        ap();
+    };
+    // A lawn plot keeps its own green: the plot colour knob is the paving's.
+    const apply = (cfg) => {
+        applyBuilding(u, cfg, undefined);
+        if (cfg.plotColor !== undefined || cfg.plot !== undefined)
+            pavU.uPavColor.value.set(cfg.plot === 'lawn' ? '#4f7a2e' : (cfg.plotColor || '#9d9892'));
+        // The streets' live knobs, handed on to every road / junction piece.
+        const live = Object.create(null);
+        if (cfg.streetAsphaltColor !== undefined)
+            live.asphaltColor = cfg.streetAsphaltColor;
+        if (cfg.streetMarkingColor !== undefined)
+            live.markingColor = cfg.streetMarkingColor;
+        if (cfg.plotColor !== undefined)
+            live.sidewalkColor = cfg.plotColor;
+        if (cfg.streetLampColor !== undefined)
+            live.lampColor = cfg.streetLampColor;
+        if (cfg.streetLampRadius !== undefined)
+            live.lampRadius = cfg.streetLampRadius;
+        if (cfg.streetLampIntensity !== undefined)
+            live.lampIntensity = cfg.streetLampIntensity;
+        for (const k of kids)
+            k.apply(live);
+    };
+    rebuild(c);
+    setTextures(c);
+    apply(c);
+    return {
+        object: group,
+        get materials() { const out = [mat, paving]; for (const k of kids)
+            out.push(...(k.materials || [])); return out; },
+        get uniformSets() { const out = [u, pavU, uR, uJ]; for (const k of kids)
+            for (const s of k.uniformSets || [])
+                if (!out.includes(s))
+                    out.push(s); return out; },
+        /** Facades and plot gather the nearest lamps (their own streets' too); the merged streets use the baked field. */
+        lampTargets() {
+            const all = this.bounds();
+            const plotB = new THREE.Box3(new THREE.Vector3(-state.ext.w / 2, 0, -state.ext.d / 2), new THREE.Vector3(state.ext.w / 2, 0.2, state.ext.d / 2));
+            const out = [];
+            out.push({ u, bounds: mesh ? mesh.userData.bounds.clone() : all }, { u: pavU, bounds: plotB });
+            if (merged.length)
+                out.push({ field, bounds: plotB });
+            return out;
+        },
+        apply,
+        rebuild(cfg) { rebuild(cfg); setTextures(cfg); apply(cfg); },
+        bounds() {
+            const b = mesh ? mesh.userData.bounds.clone() : new THREE.Box3();
+            return b.union(new THREE.Box3(new THREE.Vector3(-state.ext.w / 2, 0, -state.ext.d / 2), new THREE.Vector3(state.ext.w / 2, 0.2, state.ext.d / 2)));
+        },
+        update(dt, camera) { u.uTime.value += dt; for (const k of kids)
+            k.update(dt, camera); },
+        dispose() { clearStreets(); field.texture.dispose(); disposeInstanced(mesh); if (plot)
+            plot.geometry.dispose(); mat.dispose(); paving.dispose(); },
+    };
+}

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

@@ -0,0 +1,128 @@
+import * as THREE from 'three';
+export declare const FOOTPRINTS: string[];
+export declare const FACADES: string[];
+export declare const ROOFS: string[];
+export declare const LIGHTING: string[];
+export declare const MIXES: string[];
+/** One building's picks from a mix (null for 'custom'): { footprint, facade, roof, floors, lobby }. */
+export declare function pickMix(rng: any, mix: any): {
+    footprint: string;
+    facade: string;
+    roof: string;
+    floors: number;
+    lobby: any;
+};
+/** Structural knobs: the instance list is rebuilt when one changes. */
+export declare const STRUCTURAL: string[];
+export declare const STYLE_FACADE = 0, STYLE_SOLID = 1, STYLE_UPPER = 2, STYLE_ROOF = 3, STYLE_CROWN = 4, ROUND = 10;
+export declare const MARK_NONE = 0, MARK_HELIPAD = 1, MARK_LAWN = 2;
+/** Push the instances of one building described by `c` (building knobs) at (x, z) turned ry, into `list`. */
+export declare function addBuilding(list: any, c: any, x: any, z: any, ry?: number, tint?: number[], seed?: any): any;
+/** Turn an instance list into InstancedMeshes (one per unit geometry) with the facade attributes.
+ *  The volume's metres go into the instance matrix SCALE (so raycasts, bounds and the
+ *  selection gizmo see the real volumes); the shader reads the size back from the matrix.
+ *  Returns the box mesh; the other geometries are its children. userData.bounds is the union;
+ *  dispose with disposeInstanced(mesh). */
+export declare function buildInstancedBoxes(list: any, material: any): THREE.InstancedMesh<any, any, THREE.InstancedMeshEventMap>;
+/** Free every geometry of a buildInstancedBoxes result (the material is shared; dispose it separately). */
+export declare function disposeInstanced(mesh: any): void;
+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;
+    };
+} & {
+    uWallColor: {
+        value: THREE.Color;
+    };
+    uGlassColor: {
+        value: THREE.Color;
+    };
+    uGlassReflect: {
+        value: number;
+    };
+    uMullionColor: {
+        value: THREE.Color;
+    };
+    uRoofColor: {
+        value: THREE.Color;
+    };
+    uMullionWidth: {
+        value: number;
+    };
+    uLobby: {
+        value: number;
+    };
+    uLightColor: {
+        value: THREE.Color;
+    };
+    uCoolLightColor: {
+        value: THREE.Color;
+    };
+    uLightWarmth: {
+        value: number;
+    };
+    uWindowGlow: {
+        value: number;
+    };
+    uFlicker: {
+        value: number;
+    };
+    uTime: {
+        value: number;
+    };
+};
+/** Per-frame knobs. `tex` = the loaded texture set (or null). */
+export declare function applyConfig(u: any, c: any, tex?: any): void;
+export declare const VERT = "\nattribute vec4 aParams;\nattribute vec4 aFacade;\nattribute vec3 aTint;\nvarying vec3 vLocal;     // metres inside the volume (x,z centred, y from the base)\nvarying vec3 vLocalN;    // face normal in the volume's own frame\nvarying vec3 vSize;\nvarying vec4 vParams;\nvarying vec4 vFacade;\nvarying vec3 vTint;\nvarying vec3 vP;         // world position\nvarying vec3 vN;         // world normal\n#include <fog_pars_vertex>\nvoid main() {\n    // The volume's size is the instance matrix scale (metres); the cube is unit.\n    vec3 size = vec3(length(instanceMatrix[0].xyz), length(instanceMatrix[1].xyz), length(instanceMatrix[2].xyz));\n    vLocal = position * size;\n    vLocalN = normal;\n    vSize = size; vParams = aParams; vFacade = aFacade; vTint = aTint;\n    mat4 m = modelMatrix * instanceMatrix;\n    vec4 wp = m * vec4(position, 1.0);\n    vP = wp.xyz;\n    vN = normalize(mat3(m) * normal);\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;
+/** Lab entry: build(u, c) -> { object, mesh, apply, rebuild, update, dispose }. */
+export declare function build(u: any, c: any): {
+    object: THREE.Group<THREE.Object3DEventMap>;
+    readonly mesh: any;
+    materials: THREE.ShaderMaterial[];
+    uniformSets: any[];
+    apply(cfg: any): void;
+    rebuild(cfg: any): void;
+    bounds(): any;
+    update(dt: any): void;
+    dispose(): void;
+};
+//# sourceMappingURL=building.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"building.d.ts","sourceRoot":"","sources":["../../../../src/components/urban/core/building.ts"],"names":[],"mappings":"AA0BA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAM/B,eAAO,MAAM,UAAU,UAAuG,CAAC;AAC/H,eAAO,MAAM,OAAO,UAAyG,CAAC;AAC9H,eAAO,MAAM,KAAK,UAA8F,CAAC;AACjH,eAAO,MAAM,QAAQ,UAA2B,CAAC;AAKjD,eAAO,MAAM,KAAK,UAA2E,CAAC;AAc9F,uGAAuG;AACvG,wBAAgB,OAAO,CAAC,GAAG,KAAA,EAAE,GAAG,KAAA;;;;;;EAK/B;AAED,uEAAuE;AACvE,eAAO,MAAM,UAAU,UAAoJ,CAAC;AAQ5K,eAAO,MAAM,YAAY,IAAI,EAAE,WAAW,IAAI,EAAE,WAAW,IAAI,EAAE,UAAU,IAAI,EAAE,WAAW,IAAI,EAAE,KAAK,KAAK,CAAC;AAC7G,eAAO,MAAM,SAAS,IAAI,EAAE,YAAY,IAAI,EAAE,SAAS,IAAI,CAAC;AAI5D,6GAA6G;AAC7G,wBAAgB,WAAW,CAAC,IAAI,KAAA,EAAE,CAAC,KAAA,EAAE,CAAC,KAAA,EAAE,CAAC,KAAA,EAAE,EAAE,SAAI,EAAE,IAAI,WAAY,EAAE,IAAI,MAAY,OA+JpF;AAgFD;;;;2CAI2C;AAC3C,wBAAgB,mBAAmB,CAAC,IAAI,KAAA,EAAE,QAAQ,KAAA,8DAcjD;AACD,2GAA2G;AAC3G,wBAAgB,gBAAgB,CAAC,IAAI,KAAA,QAIpC;AAGD,wBAAgB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgB7B;AAED,iEAAiE;AACjE,wBAAgB,WAAW,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA,EAAE,GAAG,MAAY,QAehD;AAED,eAAO,MAAM,IAAI,ygCA0Bf,CAAC;AAEH,eAAO,MAAM,IAAI,QA2Pf,CAAC;AAEH,wBAAgB,cAAc,CAAC,CAAC,KAAA,wBAE/B;AAGD,mFAAmF;AACnF,wBAAgB,KAAK,CAAC,CAAC,KAAA,EAAE,CAAC,KAAA;;;;;;;;;;EAgCzB"}